

DIRECTORY
Arpa USING [Address, MyAddress, nullAddress],
ArpaUDP USING [nullPort, Port],
Ascii USING [CR, FF, LF, SP, TAB],
Basics USING [HFromCard16, IsBound, LowHalf],
BasicTime USING [earliestGMT, GMT, Now, Period, TimeNotKnown, Update],
Convert USING [RopeFromArpaAddress],
Process USING [Detach, PauseMsec],
RefText USING [Append, New, ObtainScratch, ReleaseScratch],
Rope USING [FromRefText, Length, ROPE, Substr, ToRefText],
SunPMap USING [udpPort],
SunRPC USING [Destroy, Error, Handle],
SunRPCOnUDP USING [Create, SetRemote],
SunRPCAuth USING [Conversation, Error, Initiate, Terminate],
SunYP USING [EachMapNameProc, ResponseKeyVal, ResponseVal, Status],
SunYPAgent USING [TextSeq, TextSeqObject],
SunYPAgentPrivate USING [Object, ServerObject],
SunYPClient USING [First, Maplist, Match, Next, Null],
SunYPFind USING [Error, GetDefaultDomain, GetServerAddressAndPortForDomain],
SymTab USING [Create, Fetch, Ref, Store, Update, UpdateAction, Val],
ThisMachineRegistry USING [ThisMachineProcsRec, ThisMachineRef, RegisterThisMachineProcs]
;

SunYPAgentImpl: CEDAR MONITOR
LOCKS lock USING lock: Lock
IMPORTS Arpa, Basics, BasicTime, Convert, Process, RefText, Rope, SunRPC, SunRPCOnUDP, SunRPCAuth, SunYPClient, SunYPFind, SymTab, ThisMachineRegistry
EXPORTS SunYPAgent
~ {
msecBetweenSweeps: CARD Ź 11111;
initialServerTTL: CARDINAL Ź 300;
initialCachedValueTTL: CARDINAL Ź 300;

maxCachedValues: CARDINAL Ź 31;

timeoutBase: CARD Ź 500;
timeoutMsecPerHop: CARD Ź 250;
pauseMsecPerHop: CARD Ź 100;

maxTriesForSpecifiedServer: CARDINAL Ź 8;
pauseMsecBetweenRetriesForSpecifiedServer: CARD Ź 1000;

pMapPort: ArpaUDP.Port Ź Basics.HFromCard16[Basics.LowHalf[SunPMap.udpPort]];
maxArgLength: CARDINAL Ź 100;

hostsMapName: ROPE Ź "hosts.byaddr";
hostNamePos: CARDINAL = 1;
ROPE: TYPE ~ Rope.ROPE;

Lock: TYPE ~ REF LockObject;
LockObject: TYPE ~ MONITORED RECORD [];

Error: PUBLIC ERROR [code: ATOM] ~ CODE;
Server: TYPE ~ REF ServerObject;
ServerObject: TYPE ~ SunYPAgentPrivate.ServerObject;

serverTab: SymTab.Ref Ź SymTab.Create[];

serverLock: Lock ~ NEW[LockObject];
serverList: Server Ź NIL;
nullServerLock: Lock ~ NEW[LockObject];
nullServerList: Server Ź NIL;

GetServerByAddressAndPort: ENTRY PROC [address: Arpa.Address, port: ArpaUDP.Port, lock: Lock Ź serverLock] RETURNS [server: Server] ~ {
FOR server Ź serverList, server.next
WHILE (server # NIL) AND ((server.address # address) OR (server.port # port))
DO NULL ENDLOOP;
IF server = NIL THEN {
server Ź NEW[ServerObject Ź [serverList, address, port, initialServerTTL, FALSE]];
serverList Ź server;
};
};

SweepServers: ENTRY PROC [seconds: CARD, lock: Lock Ź serverLock] ~ {
FOR server: Server Ź serverList, server.next WHILE server # NIL DO
server.ttl Ź (IF server.ttl > seconds THEN server.ttl - seconds ELSE 0);
ENDLOOP;
};

IsNullServer: PROC [server: Server] RETURNS [BOOL] ~ INLINE {
RETURN [server.address = Arpa.nullAddress] };

GetNullServer: ENTRY PROC [lock: Lock Ź nullServerLock] RETURNS [server: Server] ~ {
server Ź NEW[ServerObject Ź [nullServerList, Arpa.nullAddress, ArpaUDP.nullPort, initialServerTTL, FALSE]];
nullServerList Ź server;
};

SweepNullServers: ENTRY PROC [seconds: CARD, lock: Lock Ź nullServerLock] ~ {
prev, server: Server;
prev Ź NIL; server Ź nullServerList;
WHILE server # NIL DO
IF server.ttl > seconds
THEN {
server.ttl Ź server.ttl - seconds;
prev Ź server;
}
ELSE {
server.ttl Ź 0;
IF prev = NIL THEN nullServerList Ź server.next ELSE prev.next Ź server.next;
};
server Ź server.next;
ENDLOOP;
};

GetServerForDomain: PROC [domain: ROPE] RETURNS [server: Server] ~ {
server Ź NARROW[SymTab.Fetch[serverTab, domain].val];
SELECT TRUE FROM
(server = NIL) => NULL;
(IsNullServer[server]) => IF server.ttl = 0 THEN server Ź NIL;
(server.down) => server Ź NIL;
(server.ttl = 0) AND (NOT ServerResponding[server]) => server Ź NIL;
ENDCASE;
IF server # NIL THEN RETURN;
-- IF server = NIL THEN -- {
address: Arpa.Address Ź Arpa.nullAddress;
port: ArpaUDP.Port Ź ArpaUDP.nullPort;
[address, port] Ź SunYPFind.GetServerAddressAndPortForDomain[domain
! SunYPFind.Error => CONTINUE];
IF address # Arpa.nullAddress THEN server Ź GetServerByAddressAndPort[address, port];
};
IF server = NIL THEN {
server Ź GetNullServer[];
};
[] Ź SymTab.Store[serverTab, domain, server];
};

GetServerByAddress: PROC [address: Arpa.Address, domain: ROPE]
RETURNS [server: Server] ~ {
errorCode: ATOM Ź NIL;
port: ArpaUDP.Port;
[, port] Ź SunYPFind.GetServerAddressAndPortForDomain[domain, address
! SunYPFind.Error => { errorCode Ź code; CONTINUE } ];
IF errorCode = NIL
THEN {
server Ź GetServerByAddressAndPort[address, port];
server.down Ź FALSE;
server.ttl Ź initialServerTTL;
[] Ź SymTab.Store[serverTab, domain, server];
}
ELSE {
ERROR Error[errorCode];
};
};

ServerResponding: PROC [server: Server] RETURNS [responding: BOOL Ź FALSE] ~ {
h: SunRPC.Handle;
c: SunRPCAuth.Conversation;
IF NOT IsNullServer[server] THEN {
ENABLE SunRPC.Error, SunRPCAuth.Error => CONTINUE;
h Ź SunRPCOnUDP.Create[remoteAddress~server.address, remotePort~server.port];
c Ź SunRPCAuth.Initiate[];
server.ttl Ź initialServerTTL;
SunYPClient.Null[h, c];
responding Ź TRUE;
};
server.down Ź NOT responding;
IF h # NIL THEN SunRPC.Destroy[h]; h Ź NIL;
IF c # NIL THEN SunRPCAuth.Terminate[c]; c Ź NIL;
};
Handle: TYPE ~ REF Object;
Object: PUBLIC TYPE ~ SunYPAgentPrivate.Object;

ObtainHandle: PUBLIC PROC [domainName: ROPE, conversation: SunRPCAuth.Conversation, serverAddress: Arpa.Address] RETURNS [h: Handle] ~ {
server: Server Ź NIL;
rpcHandle: SunRPC.Handle;
serverSpecified: BOOL Ź (serverAddress # Arpa.nullAddress);
IF domainName = NIL THEN domainName Ź SunYPFind.GetDefaultDomain[];
IF serverSpecified
THEN {
FOR try: CARDINAL Ź 0, try.SUCC DO
server Ź GetServerByAddress[serverAddress, domainName
! Error => IF try >= maxTriesForSpecifiedServer THEN REJECT ELSE CONTINUE];
IF server # NIL THEN EXIT;
Process.PauseMsec[pauseMsecBetweenRetriesForSpecifiedServer];
ENDLOOP;
}
ELSE {
server Ź GetServerForDomain[domainName];
IF IsNullServer[server] THEN ERROR Error[$domainNotFound];
};
IF conversation = NIL THEN conversation Ź SunRPCAuth.Initiate[];
rpcHandle Ź SunRPCOnUDP.Create[remoteAddress~server.address, remotePort~server.port];
h Ź NEW[Object Ź [domain~domainName, server~server, rpcHandle~rpcHandle, conversation~conversation, serverSpecified~serverSpecified]];
};

RefreshHandle: PUBLIC PROC [h: Handle, conversation: SunRPCAuth.Conversation, serverAddress: Arpa.Address] ~ {
server: Server;
IF serverAddress = Arpa.nullAddress
THEN {
server Ź GetServerForDomain[h.domain];
IF IsNullServer[server] THEN ERROR Error[$domainNotFound];
}
ELSE {
server Ź GetServerByAddress[serverAddress, h.domain];
};
SunRPCAuth.Terminate[h.conversation];
h.conversation Ź IF conversation # NIL THEN conversation ELSE SunRPCAuth.Initiate[];
IF server # h.server THEN {
h.server Ź server;
h.rpcHandle Ź SunRPCOnUDP.SetRemote[h.rpcHandle, server.address, server.port];
};
};

ReleaseHandle: PUBLIC PROC [h: Handle] ~ {
IF h.rpcHandle # NIL THEN { SunRPC.Destroy[h.rpcHandle]; h.rpcHandle Ź NIL };
h.server Ź NIL;
IF h.conversation # NIL THEN { SunRPCAuth.Terminate[h.conversation]; h.conversation Ź NIL };
};

FixupForDownServer: PROC [h: Handle] RETURNS [fixed: BOOL Ź FALSE] ~ {
ENABLE Error => CONTINUE;
oldServer: Server;
IF h.serverSpecified THEN RETURN;
oldServer Ź h.server;
h.server Ź GetServerForDomain[h.domain];
IF IsNullServer[h.server] THEN RETURN;
IF h.server.address = oldServer.address THEN RETURN;
IF h.server.down THEN RETURN;
fixed Ź TRUE;
};
CachedValue: TYPE ~ REF CachedValueObject;
CachedValueObject: TYPE ~ RECORD [
next, prev: CachedValue,
ttl: CARDINAL Ź initialCachedValueTTL,
busy: CARDINAL Ź 0,
value: REF TEXT,
key: ROPE,
table: SymTab.Ref
];

cachedValueLock: Lock ~ NEW[LockObject];
cachedValueHead, cachedValueTail: CachedValue;
numCachedValues: CARD Ź 0;
cachedValueAvailable: CONDITION;

tabByDomain: SymTab.Ref ~ SymTab.Create[];

RemoveCachedValueFromTable: PROC [cV: CachedValue] ~ {
value: SymTab.Val ~ cV;
DeleteValue: SymTab.UpdateAction -- [found, val] RETURNS [op, new] -- ~ {
IF found AND val = value
THEN RETURN [delete, NIL]
ELSE RETURN [none, NIL];
};
IF (cV.table = NIL) OR (cV.key = NIL) THEN ERROR;
SymTab.Update[cV.table, cV.key, DeleteValue];
};

RemoveCachedValueFromList: INTERNAL PROC [cV: CachedValue] ~ {
IF cV = cachedValueTail
THEN cachedValueTail Ź cV.prev
ELSE cV.next.prev Ź cV.prev;
IF cV = cachedValueHead
THEN cachedValueHead Ź cV.next
ELSE cV.prev.next Ź cV.next;
};

LookupCachedValue: ENTRY PROC [domainName, mapName, key: ROPE, lock: Lock Ź cachedValueLock] RETURNS [cV: CachedValue] ~ {
tabByMap, tabByKey: SymTab.Ref;
GetTabByMap: SymTab.UpdateAction -- [found, val] RETURNS [op, new] -- ~ {
IF found
THEN { tabByMap Ź NARROW[val]; RETURN [none, NIL] }
ELSE { tabByMap Ź SymTab.Create[]; RETURN [store, tabByMap] };
};
GetTabByKey: SymTab.UpdateAction -- [found, val] RETURNS [op, new] -- ~ {
IF found
THEN { tabByKey Ź NARROW[val]; RETURN [none, NIL] }
ELSE { tabByKey Ź SymTab.Create[]; RETURN [store, tabByKey] };
};
SymTab.Update[tabByDomain, domainName, GetTabByMap];
SymTab.Update[tabByMap, mapName, GetTabByKey];
cV Ź NARROW[SymTab.Fetch[tabByKey, key].val];
SELECT TRUE FROM
(cV = NIL) => {
DO
SELECT TRUE FROM
(numCachedValues < maxCachedValues) => {
cV Ź NEW[CachedValueObject];
numCachedValues Ź numCachedValues + 1;
EXIT;
};
(cachedValueHead = NIL) => {
WAIT cachedValueAvailable;
LOOP;
};
ENDCASE => {
cV Ź cachedValueTail;
RemoveCachedValueFromTable[cV];
RemoveCachedValueFromList[cV];
EXIT;
};
ENDLOOP;
cV.ttl Ź initialCachedValueTTL;
cV.key Ź key;
cV.value Ź NIL;
cV.table Ź tabByKey;
};
(cV.busy = 0) => {
RemoveCachedValueFromList[cV];
};
ENDCASE;
cV.busy Ź cV.busy + 1;
};

CacheValue: ENTRY PROC [cV: CachedValue, newValue: REF TEXT Ź NIL, lock: Lock Ź cachedValueLock] ~ {
IF newValue # NIL THEN {
IF cV.busy # 1 THEN ERROR;
cV.value Ź newValue;
[] Ź SymTab.Store[cV.table, cV.key, cV];
};
IF (cV.busy Ź cV.busy - 1) = 0 THEN {
IF cachedValueHead = NIL
THEN {
cV.next Ź cV.prev Ź NIL;
cachedValueHead Ź cachedValueTail Ź cV;
NOTIFY cachedValueAvailable;
}
ELSE {
cV.next Ź cachedValueHead;
cV.prev Ź NIL;
cachedValueHead.prev Ź cV;
cachedValueHead Ź cV;
};
};
};

FreeCachedValue: INTERNAL PROC [cV: CachedValue, lock: Lock] ~ {
cV.key Ź NIL;
cV.value Ź NIL;
cV.table Ź NIL;
cV.next Ź cV.prev Ź NIL;
numCachedValues Ź numCachedValues - 1;
NOTIFY cachedValueAvailable;
};

ReleaseCacheEntry: ENTRY PROC [cV: CachedValue, lock: Lock Ź cachedValueLock] ~ {
IF cV.busy # 1 THEN ERROR;
FreeCachedValue[cV, lock];
};

SweepCachedValues: ENTRY PROC [seconds: CARD, lock: Lock Ź cachedValueLock] ~ {
p, next: CachedValue;
FOR p Ź cachedValueHead, next WHILE p # NIL DO
next Ź p.next;
IF p.ttl > seconds
THEN {
p.ttl Ź p.ttl - seconds;
}
ELSE {
IF p.busy # 0 THEN ERROR;
RemoveCachedValueFromTable[p];
RemoveCachedValueFromList[p];
FreeCachedValue[p, lock];
};
ENDLOOP;
};
MapErrorCode: PROC [code: ATOM, h: Handle] RETURNS [mappedCode: ATOM] ~ {
h.server.down Ź TRUE;
h.server.ttl Ź initialServerTTL;
mappedCode Ź code;
};

MapErrorStatus: PROC [status: SunYP.Status, h: Handle] RETURNS [mappedCode: ATOM] ~ {
h.server.down Ź FALSE;
h.server.ttl Ź initialServerTTL;
mappedCode Ź (SELECT status FROM
true => NIL,
nomore => $noMoreEntries,
nomap => $mapNotFound,
nodomain => $domainNotFound,
nokey => $keyNotFound,
ENDCASE => $protocol);
};

Match: PUBLIC PROC [h: Handle, map: ROPE, key: ROPE] RETURNS [val: REF TEXT] ~ {
cV: CachedValue;
errorCode: ATOM;
response: SunYP.ResponseVal;
cV Ź LookupCachedValue[h.domain, map, key];
IF cV.value # NIL THEN {
val Ź cV.value;
CacheValue[cV];
RETURN;
};
{
ENABLE SunRPC.Error => {
errorCode Ź MapErrorCode[code, h];
IF FixupForDownServer[h] THEN RETRY ELSE CONTINUE;
};
response Ź SunYPClient.Match[h.rpcHandle, h.conversation, [domain~h.domain, map~map, key~Rope.ToRefText[key]]];
errorCode Ź MapErrorStatus[response.status, h];
};
IF errorCode = NIL
THEN {
val Ź response.val;
CacheValue[cV, val];
RETURN;
}
ELSE {
ReleaseCacheEntry[cV];
ERROR Error[errorCode];
};
};

First: PUBLIC PROC [h: Handle, map: ROPE] RETURNS [key: ROPE, val: REF TEXT] ~ {
response: SunYP.ResponseKeyVal;
errorCode: ATOM Ź NIL;
{
ENABLE SunRPC.Error => {
errorCode Ź MapErrorCode[code, h];
IF FixupForDownServer[h] THEN RETRY ELSE CONTINUE;
};
response Ź SunYPClient.First[h.rpcHandle, h.conversation, [domain~h.domain, map~map]];
errorCode Ź MapErrorStatus[response.status, h];
};
IF errorCode # NIL THEN ERROR Error[errorCode];
RETURN [Rope.FromRefText[response.key], response.val];
};

Next: PUBLIC PROC [h: Handle, map: ROPE, keyBefore: ROPE]
RETURNS [key: ROPE, val: REF TEXT] ~ {
response: SunYP.ResponseKeyVal;
errorCode: ATOM Ź NIL;
{
ENABLE SunRPC.Error => {
errorCode Ź MapErrorCode[code, h];
IF FixupForDownServer[h] THEN RETRY ELSE CONTINUE;
};
response Ź SunYPClient.Next[h.rpcHandle, h.conversation, [domain~h.domain, map~map, key~Rope.ToRefText[keyBefore]]];
errorCode Ź MapErrorStatus[response.status, h];
};
IF errorCode # NIL THEN ERROR Error[errorCode];
RETURN [Rope.FromRefText[response.key], response.val];
};

MapList: PUBLIC PROC [h: Handle, eachMap: SunYP.EachMapNameProc] ~ {
status: SunYP.Status;
errorCode: ATOM Ź NIL;
gotOne: BOOL Ź FALSE;
eachMapOuter: SunYP.EachMapNameProc -- [map] -- ~ {
gotOne Ź TRUE;
RETURN [eachMap[map]];
};
{
ENABLE SunRPC.Error => {
errorCode Ź MapErrorCode[code, h];
IF (NOT gotOne) AND FixupForDownServer[h] THEN RETRY ELSE CONTINUE;
};
status Ź SunYPClient.Maplist[h.rpcHandle, h.conversation, h.domain, eachMapOuter];
errorCode Ź MapErrorStatus[status, h];
};
IF errorCode # NIL THEN ERROR Error[errorCode];
};
ExpandTextSeq: PROC [s: SunYPAgent.TextSeq] RETURNS [new: SunYPAgent.TextSeq] ~ {
new Ź NEW[SunYPAgent.TextSeqObject[2*s.maxLength]];
new.length Ź s.length;
FOR i: CARDINAL IN [0 .. s.length) DO
new.refText[i] Ź s.refText[i];
ENDLOOP;
};

IsWhiteSpace: PROC [c: CHAR] RETURNS [isWhite: BOOL] ~ {
OPEN Ascii;
isWhite Ź (SELECT c FROM
TAB, LF, FF, CR, SP => TRUE,
ENDCASE => FALSE);
};

TokenizeUsingSeparator: PUBLIC PROC [in: REF READONLY TEXT, sepChar: CHAR, trimLeadingSpace, trimTrailingSpace: BOOL] RETURNS [out: SunYPAgent.TextSeq]
~ {
i, iTo, len: CARDINAL;
scratch: REF TEXT Ź RefText.ObtainScratch[in.length];

CountSeparators: PROC [txt: REF READONLY TEXT, sepChar: CHAR] RETURNS [ct: CARDINAL Ź 0] = {
   FOR k: CARDINAL IN [0..txt.length) DO
      IF txt[k] =  sepChar THEN ct Ź ct + 1;
      ENDLOOP; 
   };
    
len Ź CountSeparators[in, sepChar] + 1;            
out Ź NEW[SunYPAgent.TextSeqObject[len]];  
out.length Ź 0;
i Ź 0;
DO
IF i >= in.length THEN EXIT;
IF trimLeadingSpace AND IsWhiteSpace[in[i]] THEN { i Ź i + 1; LOOP };
iTo Ź 0;
DO
IF (i >= in.length) OR (in[i] = sepChar) THEN EXIT;
scratch[iTo] Ź in[i];
i Ź i + 1;
iTo Ź iTo + 1;
ENDLOOP;
IF trimTrailingSpace THEN
WHILE (iTo > 0) AND IsWhiteSpace[scratch[iTo-1]] DO iTo Ź iTo - 1 ENDLOOP;
scratch.length Ź iTo;
IF out.length >= out.maxLength THEN out Ź ExpandTextSeq[out];
out.refText[out.length] Ź RefText.Append[to~RefText.New[scratch.length], from~scratch];
out.length Ź out.length + 1;
i Ź i + 1;
ENDLOOP;
scratch.length Ź 0;
FOR k: CARDINAL DECREASING IN [0..len) DO
  IF out.refText[k] = NIL THEN {
    out.refText[k] Ź RefText.Append[to~RefText.New[scratch.length], from~scratch];
  } ELSE EXIT;
  ENDLOOP;  
RefText.ReleaseScratch[scratch];
out.length Ź len;
};

Tokenize: PUBLIC PROC [in: REF READONLY TEXT]
RETURNS [out: SunYPAgent.TextSeq]
~ {
i, iTo: CARDINAL;
scratch: REF TEXT Ź RefText.ObtainScratch[in.length];
out Ź NEW[SunYPAgent.TextSeqObject[8]];
out.length Ź 0;
i Ź 0;
DO
IF i >= in.length THEN EXIT;
iTo Ź 0;
DO
IF i >= in.length THEN EXIT;
IF IsWhiteSpace[in[i]] THEN EXIT;
scratch[iTo] Ź in[i];
i Ź i + 1;
iTo Ź iTo + 1;
ENDLOOP;
scratch.length Ź iTo;
IF out.length >= out.maxLength THEN out Ź ExpandTextSeq[out];
out.refText[out.length] Ź RefText.Append[to~RefText.New[scratch.length], from~scratch];
out.length Ź out.length + 1;
i Ź i + 1;
WHILE (i < in.length) AND (IsWhiteSpace[in[i]]) DO i Ź i + 1 ENDLOOP;
ENDLOOP;
RefText.ReleaseScratch[scratch];
};

lastSweepTime: BasicTime.GMT Ź BasicTime.earliestGMT;

Daemon: PROC ~ {
DO
thisSweepTime: BasicTime.GMT;
secondsSinceLastSweep: INT;
secs: CARD; -- signed/unsigned ambiguity ... bletch!
thisSweepTime Ź BasicTime.Now[
! BasicTime.TimeNotKnown => {
thisSweepTime Ź BasicTime.Update[lastSweepTime, (msecBetweenSweeps+999)/1000];
CONTINUE;
}
];
secondsSinceLastSweep Ź BasicTime.Period[from~lastSweepTime, to~thisSweepTime];
IF secondsSinceLastSweep < 0 THEN ERROR;
secs Ź secondsSinceLastSweep;
SweepCachedValues[secs];
SweepServers[secs];
SweepNullServers[secs];
Process.PauseMsec[msecBetweenSweeps];
ENDLOOP;
};

IPNameProc: PROC RETURNS [name: ROPE] = {
ENABLE Error => GOTO NoYP;
h: Handle Ź NIL;
addressRope, unbracketedAddressRope: ROPE;
hostsEntry: REF TEXT;
seq: SunYPAgent.TextSeq;

h Ź ObtainHandle[NIL, NIL, Arpa.nullAddress];
addressRope Ź Convert.RopeFromArpaAddress[Arpa.MyAddress[]];
unbracketedAddressRope Ź Rope.Substr[addressRope, 1, Rope.Length[addressRope]-2];
hostsEntry Ź Match[h, hostsMapName, unbracketedAddressRope];
seq Ź Tokenize[hostsEntry];
IF seq.length <= hostNamePos THEN GOTO NoYP;
name Ź Rope.FromRefText[seq.refText[hostNamePos]];
IF h # NIL THEN ReleaseHandle[h];
EXITS
NoYP => NULL;
};
IPAddressProc: PROC RETURNS [ROPE] = {
RETURN[Convert.RopeFromArpaAddress[Arpa.MyAddress[]]];
};    

Init: PROC = {
thisMachineProcs: ThisMachineRegistry.ThisMachineRef Ź
NEW[ThisMachineRegistry.ThisMachineProcsRec Ź [
which: $ip,
Name: IPNameProc,
Address: IPAddressProc,
ProcessorID: NIL
]];
IF Basics.IsBound[LOOPHOLE[ThisMachineRegistry.RegisterThisMachineProcs]] THEN
ThisMachineRegistry.RegisterThisMachineProcs[thisMachineProcs];
};


TRUSTED { Process.Detach[ FORK Daemon[] ] };
Init[];

}...
  F  SunYPAgentImpl.mesa
Copyright Ó 1989, 1991, 1992 by Xerox Corporation.  All rights reserved.
Demers, November 28, 1988 10:47:03 am PST
Alan Ishigo November 29, 1988 2:24:19 pm PST
Willie-sue, January 18, 1993 3:27 pm PST

TODO: the null server stuff is baroque.
Chauser, January 3, 1992 11:07 am PST
Parameters
Types
Server Cache
This never raises Error, may store a down server in serverTab.
NOTE: ServerResponding[server] will set server.down appropriately.
Raises Error if the specified server can't be contacted or doesn't serve the specified domain.
Handles
Match Response Cache
Public Procedures
Utilities
Make sure each element of the seq is not NIL ... must have at least have a zero length rope
Sweep Daemon and Rollback
Rollback: Booting.RollbackProc ~ {
SweepCachedValues[CARD.LAST];
SweepServers[CARD.LAST];
SweepNullServers[CARD.LAST];
};

Proc passed to ThisMachineRegistry to register the IP name proc with the ThisMachine interface
Proc will be passed to ThisMachineRegistry to register with the ThisMachine interface.
Mainline code
Booting.RegisterProcs[r: Rollback];
ĘĹ  (cedarcode) styleNewlineDelimiter
 codeK
Ďe=HK)K,K(K K'K%K Ďk		K#-KK"K!-K
%FK$K"K.;K:KK&K&K,<K8CK*K/K%6K
=LK8DK@YKK ĎnKKKK
K	 K!K&K KK KKKK K)K+7K KMKK K$KKK KK	'K K
(K "4K K(K K#KK'KK F
"rK
K	>RKKKK E*
BKHKKK 
=K'-K TK	WkKKK "MKK$
K"KKKKMKKKKK 
DK>K	&5K
K
>K'DKBKK
ĎcK)K&KYcK3UK
KKK--KK ![K^KKKo|K22KKK--KKKKK 
NKK"K#2KMMKKKKKKK+K1KKK/K 
EKKK&;K+C
"55K#KK
K==KKK((K:KK&@KUUKKK TnK!#K&K:KK55KK%K	TKKNKKK *K.MKK:\KK 
	FK
KK!KK(K&K&4KKKK*"KK&KKK
KKK K(K.KK	 K K*K 6K $IK
KKK1K--KK >KKKKKK 
zK $IK3K>K $IK3K>KK4K..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 
#dKKK((K%KK'KKKK
KKKKKK "@K	KKKK&&KKK 4QKKKK #OK.KKKKKKKKKK
IKK KKK #UKK  KKKKKKKK PKKKK+KKKKK""K
2KKoK//KKKKKKKKKK PKKK""K
2KKVK//KK/K06KK `KKK""K
2KKtK//KK/K06KK 0DKKK$ 3K	KKK""K	CKKRK&&KK/K	QK*3K%KKKK 
8KKKKK 'KKK	$5K K	\K(K,KK
K33K"+KKKKEKK3KK
KKKJKK=KWKK
KK[KK	

)K KRKKK KKK OKKK	$5K'KKKKKK!KK
KKKK=KWKK
KEKK KK K5K KKK (4KNNK	KKKOOK(KKKKK%%KKK "KKKKK K_
)K
KK%*KK K-K<<KQQK<<KK,K22K!KKKKXX&K06KK K79ąK0@KK K K,KK##K K     E¤  `Ż  