DIRECTORY
Convert,
IO,
List,
NameService,
NetworkName,
NS,
NMS,
MS,
Rope,
RuntimeError,
SunRPCOnNetworkStream,
SunRPCAuth,
SunRPC,
SunRPCBinding,
ThisMachine,
UnixSysCalls;

NameServiceImpl: CEDAR MONITOR
IMPORTS Convert, IO, List, NetworkName, NMS, Rope, RuntimeError, SunRPCOnNetworkStream, SunRPCAuth, SunRPCBinding, ThisMachine, UnixSysCalls
EXPORTS NameService = 
BEGIN

OPEN NameService;

ROPE: TYPE = Rope.ROPE;

TypeRope: ROPE _ "Type";
InstanceRope: ROPE _ "Instance";
SBHRope: ROPE _ "SBH";
HostRope: ROPE _ "Host";
ApplRope: ROPE _ "Appl";

RegKindValRope: ROPE _ "com.xerox.parc.rpc-service-registration-1";

ThisHostName: ROPE;
MyPid: INT _ 0;

h: SunRPC.Handle;
ns: NMS.NMS2;

BadList: ERROR = CODE;


ExportRPCSun:  PUBLIC PROC [name: ROPE, sp: SunRPC.Server, prog, vers: INT, proto: SunRPCBinding.Transport ¬ $TCP, instance: ROPE _ NIL, appl: List.LORA _ NIL] RETURNS [sbh: ROPE, uid: ROPE] = {
sbh _ GetSBH[sp, prog, vers, proto];
uid _ NMSExport[name, instance, sbh, appl];
};

ReexportRPCSun:  PUBLIC PROC [uid: ROPE, name: ROPE, sp: SunRPC.Server, prog, vers: INT, proto: SunRPCBinding.Transport ¬ $TCP, instance: ROPE _ NIL, appl: List.LORA _ NIL] RETURNS [sbh: ROPE] = {
sbh _ GetSBH[sp, prog, vers, proto];
NMSReexport[uid, name, instance, sbh, appl];
};


ImportRPCSun: PUBLIC PROC [name: ROPE _ NIL, instance: ROPE _ NIL, host: ROPE _ NIL, appl: List.LORA _ NIL] RETURNS [h: SunRPC.Handle, r: Registration] = {
regList: LIST OF Registration;
prog, vers: INT;
proto: SunRPCBinding.Transport;
hostAddr: ROPE;
port: CARD;

regList _ ImportRegistrations[name, instance, host, appl];
IF regList.rest # NIL THEN ERROR;

r _ regList.first;
IF r.sbh = NIL THEN ERROR;
[prog, vers, proto, hostAddr, port] _ SBHFromRope[NARROW[r.sbh, ROPE]];
h _ SunRPCBinding.Import[hostAddr, prog, vers,, proto];
};


ImportRegistrations: PUBLIC PROC [name: ROPE _ NIL, instance: ROPE _ NIL, host: ROPE _ NIL, appl: List.LORA] RETURNS [regList: LIST OF Registration] =
BEGIN
alist: List.LORA _ NIL;
pList: NS.ProjectionList;
ret: NS.Findreturn;
reg: Registration;

IF appl # NIL THEN alist _ CONS[List.DotCons[ApplRope, appl], alist];
IF name # NIL THEN alist _ CONS[List.DotCons[TypeRope, name], alist];
IF instance # NIL THEN alist _ CONS[List.DotCons[InstanceRope, instance], alist];
IF host # NIL THEN alist _ CONS[List.DotCons[HostRope, host], alist];
pList _ NEW [NS.SeqType2Object[0]];
ret _ ns.nsfind[ns, ToObj[alist], pList, localArea];
regList _ NIL;
SELECT ret.returnCode FROM
Success => {
r: REF NS.FindreturnObject.Success _ NARROW[ret];
SELECT r.objects.pType FROM
complete => {
ro: REF NS.FoundObjectsObject.complete _ NARROW[r.objects];
FOR i: CARD DECREASING IN [0..ro.objects.size) DO
reg _ ConstructRegRecord[FromObj[ro.objects[i]]];
regList _ CONS[reg, regList];
ENDLOOP;
};
ENDCASE => ERROR;
};
ENDCASE => ERROR;
END;


SBHToRope: PUBLIC PROC [prog, vers: INT, proto: SunRPCBinding.Transport, hostAddr: ROPE, port: CARD] RETURNS [sbh: ROPE] =
BEGIN
hProg: ROPE _ IO.PutFR1["%x", IO.int[prog]];
hexProg: ROPE _ Rope.Substr[hProg, 0, Rope.Length[hProg]-1];
sbh _ IO.PutFR["sunrpc_2_0x%g_%g|", IO.rope[hProg], IO.int[vers]];
IF proto = $TCP THEN sbh _ Rope.Concat[sbh, "tcp_"]
ELSE sbh _ Rope.Concat[sbh, "tcp_"];
sbh _ Rope.Cat[sbh, hostAddr, "_", Convert.RopeFromInt[port]];
END;

SBHFromRope: PUBLIC PROC [sbh: ROPE] RETURNS [prog, vers: INT, proto: SunRPCBinding.Transport, hostAddr: ROPE, port: CARD] =
BEGIN
index: INT;

sbh _ Rope.Substr[sbh, 11];
index _ Rope.SkipTo[sbh, 0, "_"];
prog _ Convert.IntFromRope[Rope.Substr[sbh, 0, index], 16];
sbh _ Rope.Substr[sbh, index+1];
index _ Rope.SkipTo[sbh, 0, "|"];
vers _ Convert.IntFromRope[Rope.Substr[sbh, 0, index]];
sbh _ Rope.Substr[sbh, index+1];
IF Rope.Fetch[sbh, 0] = 'u THEN proto _ $UDP
ELSE IF Rope.Fetch[sbh, 0] = 't THEN proto _ $TCP
ELSE ERROR;
sbh _ Rope.Substr[sbh, 4];
index _ Rope.SkipTo[sbh, 0, "_"];
hostAddr _ Rope.Substr[sbh, 0, index];
sbh _ Rope.Substr[sbh, index+1];
port _ Convert.IntFromRope[sbh];
END;


GetSBH: PROC [sp: SunRPC.Server, prog, vers: INT, proto: SunRPCBinding.Transport] RETURNS [sbh: ROPE] =
BEGIN
hostAddr: ROPE;
port: CARD;
s: SunRPC.Server;

s _ SunRPCBinding.Export[sp, NIL, proto];
hostAddr _ NetworkName.AddressFromName[family: $ARPA, name: ThisHostName, components: host].addr;
port _ PortFromNetworkStreamServer[s];
sbh _ SBHToRope[prog, vers, proto, hostAddr, port];
END;

NMSExport: PROC [name, instance, sbh: ROPE, appl: List.LORA] RETURNS [exportedUid: ROPE] =
BEGIN
alist: List.LORA;
ret: NS.Insertreturn;

alist _ MakeAlist[name, instance, sbh, appl];
ret _ ns.nsinsert[ns, RegKindValRope, ToObj[alist], MyPid, NS.Domain.localArea];
SELECT ret.returnCode FROM
Success => {
r: REF NS.InsertreturnObject.Success _ NARROW[ret];
exportedUid _ r.uid;
};
ENDCASE => ERROR;
END;

NMSReexport: PROC [uid: ROPE, name, instance, sbh: ROPE, appl: List.LORA] =
BEGIN
alist: List.LORA;
ret: NS.ReturnCodes;

alist _ MakeAlist[name, instance, sbh, appl];
ret _ ns.nsreplace[ns, RegKindValRope, ToObj[alist], uid, NS.Domain.localArea];
IF ret # Success THEN ERROR;
END;

MakeAlist: PROC [name, instance, sbh: ROPE, appl: List.LORA] RETURNS [alist: List.LORA] =
BEGIN
IF appl # NIL THEN alist _ CONS[List.DotCons[ApplRope, appl], NIL]
ELSE alist _ NIL;
alist _ CONS[List.DotCons[SBHRope, sbh], alist];
alist _ CONS[List.DotCons[TypeRope, name], alist];
alist _ CONS[List.DotCons[InstanceRope, instance], alist];
alist _ CONS[List.DotCons[HostRope, ThisHostName], alist];
END;

ToObj: PROC [alist: List.LORA] RETURNS [o: NS.Object] =
BEGIN
l: CARD;
av: List.DottedPair;
key: ROPE;

IF alist = NIL THEN RETURN [NIL];
l _ List.Length[alist];
o _ NEW[NS.SeqType1Object[l]];
FOR i: CARD IN [0..l) DO
av _ NARROW[alist.first, List.DottedPair];
alist _ alist.rest;
IF NOT ISTYPE[av.key, ROPE] THEN 
ERROR BadList;
o[i].name _ NARROW[av.key, ROPE];
IF av.val = NIL THEN {
o[i].value _ NEW [NS.ValueObject.text _ [text[""]]];
}
ELSE  {
IF ISTYPE[av.val, ROPE] THEN {
o[i].value _ NEW [NS.ValueObject.text _ [text[NARROW[av.val, ROPE]]]];
}
ELSE IF ISTYPE[av.val, List.LORA] THEN {
o[i].value _ NEW [NS.ValueObject.attributes _ [attributes[ToObj1[NARROW[av.val, List.LORA]]]]];
}
ELSE ERROR BadList;
};
ENDLOOP;
END;

ToObj1: PROC [alist: List.LORA] RETURNS [o: NS.SeqType0] =
BEGIN
l: CARD;
av: List.DottedPair;
key: ROPE;

IF alist = NIL THEN RETURN [NIL];
l _ List.Length[alist];
o _ NEW[NS.SeqType0Object[l]];
FOR i: CARD IN [0..l) DO
av _ NARROW[alist.first, List.DottedPair];
alist _ alist.rest;
IF NOT ISTYPE[av.key, ROPE] THEN 
ERROR BadList;
o[i].name _ NARROW[av.key, ROPE];
IF av.val = NIL THEN {
o[i].value _ NEW [NS.ValueObject.text _ [text[""]]];
}
ELSE  {
IF ISTYPE[av.val, ROPE] THEN {
o[i].value _ NEW [NS.ValueObject.text _ [text[NARROW[av.val, ROPE]]]];
}
ELSE IF ISTYPE[av.val, List.LORA] THEN {
o[i].value _ NEW [NS.ValueObject.attributes _ [attributes[ToObj1[NARROW[av.val, List.LORA]]]]];
}
ELSE ERROR BadList;
};
ENDLOOP;
END;

ListAssoc: PROC [key: ROPE, alist: List.LORA] RETURNS [val: REF ANY] =
BEGIN
av: List.DottedPair;

FOR i: CARD IN [0..List.Length[alist]) DO
av _ NARROW[alist.first, List.DottedPair];
alist _ alist.rest;
IF Rope.Equal[key, NARROW[av.key, ROPE]] THEN {
val _ av.val;
RETURN;
};
ENDLOOP;
END;

FromObj: PROC [o: NS.Object] RETURNS [alist: List.LORA] =
BEGIN
alist _ NIL;
FOR i: CARD DECREASING IN [0..o.size) DO
alist _ CONS[FromAttr[o[i]], alist];
ENDLOOP;
END;

FromObj1: PROC [o: NS.SeqType0] RETURNS [alist: List.LORA] =
BEGIN
alist _ NIL;
FOR i: CARD DECREASING IN [0..o.size) DO
alist _ CONS[FromAttr[o[i]], alist];
ENDLOOP;
END;

FromAttr: PROC [a: NS.Attribute] RETURNS [av: List.DottedPair] =
BEGIN
SELECT a.value.vType FROM
text => {
at: REF NS.ValueObject.text _ NARROW[a.value];
av _ List.DotCons[a.name, at.valStr];
};
attributes => {
aa: REF NS.ValueObject.attributes _ NARROW[a.value];
av _ List.DotCons[a.name, FromObj1[aa.valPairs]];
};
ENDCASE => ERROR;
END;

ConstructRegRecord: PROC [alist: List.LORA] RETURNS [r: Registration] =
BEGIN
r _ NEW [RegistrationRecord];
r.name _ NARROW[ListAssoc[TypeRope, alist]];
r.instance _ NARROW[ListAssoc[InstanceRope, alist]];
r.host _ NARROW[ListAssoc[HostRope, alist]];
r.sbh _ NARROW[ListAssoc[SBHRope, alist]];
r.appl _ CONS[ListAssoc[ApplRope, alist], NIL];
END;

PortFromNetworkStreamServer: PROC [s: SunRPC.Server] RETURNS [CARD] ~ {
rope: ROPE ~ NetworkName.AddressFromName[family: $ARPA, name: SunRPCOnNetworkStream.GetServerAddress[s].local, components: port].addr;
IF Rope.Match[":*", rope] THEN RETURN [Convert.CardFromRope[Rope.Substr[rope, 1]]] ELSE ERROR;
};



Start: PROC [] =
BEGIN
ENABLE RuntimeError.UNCAUGHT => GO TO Oops;
ThisHostName _ ThisMachine.Name[];
MyPid _ UnixSysCalls.GetPID[];
h _ SunRPCBinding.Import[ThisHostName, NMS.NMSPrognum, NMS.version2,, $TCP];
ns _ NMS.MakeNMS2Client[h, SunRPCAuth.Initiate[]];
EXITS Oops => {};
END;

Start[];

END.

Ό
NameServiceImpl.mesa
Copyright Σ 1992 by Xerox Corporation.  All rights reserved.
Theimer, April 29, 1993 11:58 am PDT
*** NOTE *** We would really like to be able to specify the port here instead of having Import look it up in the PortMapper.  The current implementation precludes multiple servers from exporting the same RPC interface from the same host.
Get rid of leading "sunrpc_2_0x".
Skip over either "udp_" or "tcp_".
Start Code
Κ
•NewlineDelimiter

™™Jšœ
Οe
œ1™<J™$—J˜
codeš
Οk	˜	K˜Kšžœ
˜K˜K˜K˜Kšžœ
˜Kšžœ
˜Kšžœ
˜K˜K˜
K˜K˜K˜K˜K˜K˜
—K˜šΟnœžœ
ž˜Kšžœ
žœžœa˜Œ
Kšžœ˜—Kš
ž˜K˜Kšžœ
˜K˜Kšžœžœžœ
˜K˜Kšœ
žœ
˜Kšœžœ˜ Kšœ	žœ	˜Kšœ
žœ
˜Kšœ
žœ
˜K˜Kšœžœ/˜CK˜Kšœžœ
˜Kšœžœ
˜K˜K˜Kšœžœ
žœ
˜
K˜KšŸœžœžœ
˜K˜K˜šŸœžœ
žœžœ!žœ3žœžœ
žœžœžœžœžœ˜Β
K˜$K˜+K˜—K˜šŸœžœ
žœžœžœ!žœ3žœžœ
žœžœžœžœ˜Δ
K˜$K˜,K˜—K˜K˜šŸœžœ
žœžœžœžœžœžœžœ
žœžœžœ(˜›
Kšœ	žœ
˜Kšœžœ
˜K˜Kšœ
žœ
˜Kšœžœ
˜K˜K˜:Kšžœžœ
žœ
žœ
˜!K˜K˜Kšžœ	žœ
žœ
žœ
˜Kšœ2žœžœ˜G˜7K™ν
—K˜—K˜K˜šŸœžœ
žœžœžœžœžœžœžœ
žœžœ
ž	œ˜–
Kš
ž˜Kšœž
œ
˜Kšœžœ˜Kšœžœ˜K˜K˜Kšžœžœ
žœ	žœ&˜EKšžœžœ
žœ	žœ&˜EKšžœžœ
žœ	žœ.˜QKšžœžœ
žœ	žœ&˜EKšœžœžœ˜#K˜4Kšœ
žœ
˜šžœž˜˜Kšœžœ
žœžœ˜1šžœž˜˜
Kšœžœ
žœžœ˜;š	žœžœ
ž
œ
žœž˜1K˜1Kšœ
žœ˜Kšžœ
˜—K˜—Kšžœžœ
˜—K˜—Kšžœžœ
˜—Kšžœ
˜—K˜K˜šΠbn	œžœžœ,žœžœžœžœ˜zKš
ž˜Kšœžœžœžœ˜,Kšœ	žœ/˜<Kšœžœžœžœ˜BKšžœžœ˜3Kšžœ ˜$K˜>Kšžœ
˜—K˜šŸœžœžœžœžœ,žœžœ˜|Kš
ž˜Kšœžœ
˜K˜˜K™!—K˜!K˜;K˜ K˜!K˜7K˜ Kšžœžœ
˜,Kšžœ
žœžœ
˜1Kšžœ
žœ
˜˜K™"—K˜!K˜&K˜ K˜ Kšžœ
˜—K˜K˜š
Ÿœžœ!žœ"žœžœ˜gKš
ž˜Kšœ
žœ
˜Kšœžœ
˜K˜K˜Kšœžœ	˜)K˜aK˜&K˜3Kšžœ
˜—K˜š 	œžœžœ
žœžœžœ˜ZKš
ž˜Kšœžœ
˜Kšœžœ˜K˜K˜-Kšœ;žœ˜Pšžœž˜˜Kšœžœ
žœžœ˜3K˜K˜—Kšžœžœ
˜—Kšžœ
˜—K˜š
 œžœžœžœ
žœ˜KKš
ž˜Kšœžœ
˜Kšœžœ
˜K˜K˜-Kšœ:žœ˜OKšžœžœ
žœ
˜Kš
ž˜—K˜šŸ	œžœžœ
žœžœžœ˜YKš
ž˜Kš
žœžœ
žœ	žœžœ
˜BKšžœ	žœ
˜Kšœžœ$˜0Kšœžœ&˜2Kšœžœ.˜:Kšœžœ.˜:Kšžœ
˜—K˜š
Ÿœžœžœžœžœ
˜7Kš
ž˜Kšœžœ
˜K˜Kšœžœ
˜
K˜Kš
žœ	žœ
žœ
žœžœ˜!K˜Kšœžœ
žœ˜šžœžœ
žœž˜Kšœžœ˜*K˜š
žœ
žœ
žœ	žœžœ
˜!Kšžœ	˜—Kšœžœ	žœ˜!šžœ
žœ
žœ˜Kšœ
žœžœ ˜4K˜
—šžœ˜šžœ
žœ	žœžœ˜Kš	œ
žœžœžœ	žœ˜FK˜
—š
žœ
žœ
žœžœžœ˜(Kš	œ
žœžœ-žœžœ˜_K˜
—Kšžœ
žœ	˜K˜—Kšžœ
˜—Kšžœ
˜—K˜š
Ÿœžœžœžœžœ˜:Kš
ž˜Kšœžœ
˜K˜Kšœžœ
˜
K˜Kš
žœ	žœ
žœ
žœžœ˜!K˜Kšœžœ
žœ˜šžœžœ
žœž˜Kšœžœ˜*K˜š
žœ
žœ
žœ	žœžœ
˜!Kšžœ	˜—Kšœžœ	žœ˜!šžœ
žœ
žœ˜Kšœ
žœžœ ˜4K˜
—šžœ˜šžœ
žœ	žœžœ˜Kš	œ
žœžœžœ	žœ˜FK˜
—š
žœ
žœ
žœžœžœ˜(Kš	œ
žœžœ-žœžœ˜_K˜
—Kšžœ
žœ	˜K˜—Kšžœ
˜—Kšžœ
˜—K˜šŸ	œžœžœžœžœžœ
žœ˜FKš
ž˜K˜K˜šžœžœ
žœž˜)Kšœžœ˜*K˜šžœžœ	žœžœ˜/K˜
Kšžœ
˜K˜—Kšžœ
˜—Kšžœ
˜—K˜š
Ÿœžœžœ	žœžœ˜9Kš
ž˜Kšœžœ
˜š	žœžœ
ž
œ
žœ
ž˜(Kšœžœ˜$Kšžœ
˜—Kšžœ
˜—K˜š
Ÿœžœžœžœžœ˜<Kš
ž˜Kšœžœ
˜š	žœžœ
ž
œ
žœ
ž˜(Kšœžœ˜$Kšžœ
˜—Kšžœ
˜—K˜šŸœžœžœžœ˜@Kš
ž˜šžœž˜˜	Kšœžœ
žœžœ
˜.K˜%K˜—˜Kšœžœ
žœžœ
˜4K˜1K˜—Kšžœžœ
˜—Kšžœ
˜—K˜šΟbœžœžœžœ˜GKš
ž˜Kšœžœ˜Kšœ	žœ˜,Kšœ
žœ!˜4Kšœ	žœ˜,Kšœžœ˜*Kšœ	žœžœ˜/Kšžœ
˜—K˜šŸœžœžœžœ˜GKšœžœ|˜†
Kš
žœžœ
žœ.žœ
žœ
˜^Kš
œ˜—K˜K˜K™
K˜šŸœžœ˜Kš
ž˜Kšžœžœžœ
žœ˜+K˜"K˜Kšœ'žœ
žœ˜LKšœžœ*˜2Kšžœ˜Kšžœ
˜—K˜K˜K˜Kšžœ
˜—…—"Έ1‚