DIRECTORY
GVBasics USING[ Connect, GVString, oldestTime, Password, MakeKey, Remark, RName, Timestamp ],
Rope USING[ ROPE ];

GVNames: CEDAR DEFINITIONS IMPORTS GVBasics = BEGIN OPEN Rope;

Outcome: TYPE = { -- possible outcomes of RS operations 
noChange, -- updates and timestamped enquiries
group, individual, notFound, -- any
protocolError, wrongServer, allDown, -- any
badPwd, -- authentication and updates
outOfDate, notAllowed -- updates
};

NameType: TYPE = Outcome[noChange..badPwd]; -- outcomes for enquiries

Password: TYPE = GVBasics.Password;
Timestamp: TYPE = GVBasics.Timestamp;
oldestTime: Timestamp = GVBasics.oldestTime;


RName: TYPE = GVBasics.RName;
RListHandle: TYPE = LIST OF RName;


ExpandInfo: TYPE = RECORD[ SELECT type: NameType[noChange..allDown] FROM
noChange => NULL,
group => [ members: RListHandle,
stamp: Timestamp,
count: INT ],
individual => [ sites: RListHandle,
stamp: Timestamp,
count: INT ],
notFound => NULL,
protocolError => NULL,
wrongServer => NULL,
allDown => NULL,
ENDCASE ];

Expand: PROC[name: RName, oldStamp: Timestamp _ oldestTime, reporter: ReporterProc _ NIL] RETURNS[ ExpandInfo ];


MemberInfo: TYPE = RECORD[ SELECT type: NameType[noChange..allDown] FROM
noChange => NULL,
group => [ members: RListHandle,
stamp: Timestamp,
count: INT ],
individual => NULL,
notFound => NULL,
protocolError => NULL,
wrongServer => NULL,
allDown => NULL,
ENDCASE ];

GetMembers: PROC[name: RName, oldStamp: Timestamp _ oldestTime] RETURNS[ MemberInfo ] = INLINE { RETURN[ GetList[name, oldStamp, members] ] };

GetOwners: PROC[name: RName, oldStamp: Timestamp _ oldestTime] RETURNS[ MemberInfo ] = INLINE { RETURN[ GetList[name, oldStamp, owners] ] };

GetFriends: PROC[name: RName, oldStamp: Timestamp _ oldestTime] RETURNS[ MemberInfo ] = INLINE { RETURN[ GetList[name, oldStamp, friends] ] };

GetList: PROC[name: RName, oldStamp: Timestamp, list: ListType, reporter: ReporterProc _ NIL] RETURNS[MemberInfo];


StampInfo: TYPE = NameType[noChange..allDown];

CheckStamp: PROC[name: RName, oldStamp: Timestamp _ oldestTime, reporter: ReporterProc _ NIL] RETURNS[ StampInfo ];


ConnectInfo: TYPE = NameType[group..allDown];

GetConnect: PROC[name: RName, reporter: ReporterProc _ NIL] RETURNS[ info: ConnectInfo, connect: GVBasics.Connect ];


RemarkInfo: TYPE = NameType[group..allDown];

GetRemark: PROC[name: RName, reporter: ReporterProc _ NIL] RETURNS[ info: RemarkInfo, remark: GVBasics.Remark ];


GetEntryInfo: TYPE = RECORD[
name: RName,
stamp: Timestamp,
body: SELECT type: * FROM
group => [
remark: GVBasics.Remark,
remarkStamp: Timestamp,
members: GetEntryList,
owners: GetEntryList,
friends: GetEntryList],
individual => [
password: Password,
passwordStamp: Timestamp,
connect: GVBasics.Connect,
connectStamp: Timestamp,
forward: GetEntryList,
sites: GetEntryList],
notFound => NULL,
dead => NULL,
ENDCASE ];

GetEntryList: TYPE = RECORD[
current: RListHandle,
currentStamps: LIST OF Timestamp,
deleted: RListHandle,
deletedStamps: LIST OF Timestamp];

GetEntry: PRIVATE PROC[name: RName, reporter: ReporterProc _ NIL] RETURNS[rc: NameType[group..allDown], info: REF GetEntryInfo];


AuthenticateInfo: TYPE = NameType[group..badPwd];

Authenticate: PROC[name: RName, password: ROPE] RETURNS[ AuthenticateInfo ] = INLINE { RETURN[ AuthenticateKey[name, GVBasics.MakeKey[password]] ] };

AuthenticateKey: PROC[name: RName, key: Password, reporter: ReporterProc _ NIL] RETURNS[ AuthenticateInfo ];
AuthenticatedGetEntry: PROC [user: RName _ NIL, password: Password _ [,,,], name: RName, reporter: GVNames.ReporterProc _ NIL] RETURNS [rc: GVNames.NameType[group..allDown], info: REF GVNames.GetEntryInfo];


Membership: TYPE = { yes, no, notGroup, allDown };
IsMemberDirect: PROC[name: RName, member: RName] RETURNS[ Membership ] = INLINE {
RETURN[IsInList[name, member, direct, self, members]] };

IsOwnerDirect: PROC[name: RName, owner: RName] RETURNS[ Membership ] = INLINE {
RETURN[IsInList[name, owner, direct, self, owners]] };

IsFriendDirect: PROC[name: RName, friend: RName] RETURNS[ Membership ] = INLINE {
RETURN[IsInList[name, friend, direct, self, friends]] };

IsMemberClosure: PROC[name: RName, member: RName] RETURNS[ Membership ] = INLINE {
RETURN[IsInList[name, member, closure, self, members]] };

IsOwnerClosure: PROC[name: RName, owner: RName] RETURNS[ Membership ] = INLINE {
RETURN[IsInList[name, owner, closure, self, owners]] };

IsFriendClosure:PROC[name: RName, friend: RName] RETURNS[ Membership ] = INLINE {
RETURN[IsInList[name, friend, closure, self, friends]] };

IsMemberUpArrow:PROC[name: RName, member: RName] RETURNS[ Membership ] = INLINE {
RETURN[IsInList[name, member, upArrow, self, members]] };

IsOwnerUpArrow: PROC[name: RName, owner: RName] RETURNS[ Membership ] = INLINE {
RETURN[IsInList[name, owner, upArrow, self, owners]] };

IsFriendUpArrow:PROC[name: RName, friend: RName] RETURNS[ Membership ] = INLINE {
RETURN[IsInList[name, friend, upArrow, self, friends]] };

MembershipLevel: TYPE = MACHINE DEPENDENT { direct(0), closure(1), upArrow(2) };
MembershipGrade: TYPE = MACHINE DEPENDENT { self(0), registry(1) };
ListType: TYPE = MACHINE DEPENDENT { members(0), owners(1), friends(2) };

IsInList: PROC[name: RName, member: RName, level: MembershipLevel, grade: MembershipGrade, acl: ListType, reporter: ReporterProc _ NIL] RETURNS[Membership];




CreateIndividual: PROC[user: RName, password: Password, individual: RName, newPwd: Password ] RETURNS[Outcome] = INLINE { RETURN[ Update[user, password, CreateIndividual, individual, NIL, newPwd] ] };

DeleteIndividual: PROC[user: RName, password: Password, individual: RName] RETURNS[Outcome] = INLINE { RETURN[ Update[user, password, DeleteIndividual, individual] ] };

CreateGroup: PROC[user: RName, password: Password, group: RName] RETURNS[Outcome] = INLINE {
RETURN[ Update[user, password, CreateGroup, group] ] };

DeleteGroup: PROC[user: RName, password: Password, group: RName] RETURNS[Outcome] = INLINE {
RETURN[ Update[user, password, DeleteGroup, group] ] };  


SetPassword: PROC[user: RName, password: Password, individual: RName, newPwd: Password] RETURNS[Outcome] = INLINE {
RETURN[ Update[user, password, ChangePassword, individual, NIL, newPwd] ] };

SetConnect: PROC[user: RName, password: Password, individual: RName, connect: GVBasics.Connect] RETURNS[Outcome] = INLINE {
RETURN[ Update[user, password, ChangeConnect, individual, connect] ] };

SetRemark: PROC[user: RName, password: Password, group: RName, remark: GVBasics.Remark] RETURNS[Outcome] = INLINE {
RETURN[ Update[user, password, ChangeRemark, group, remark] ] };


AddMailbox: PROC[user: RName, password: Password, individual: RName, site: RName] RETURNS[Outcome] = INLINE {
RETURN[ Update[user, password, AddMailBox, individual, site] ] };

AddForward: PROC[user: RName, password: Password, individual: RName, dest: RName] RETURNS[Outcome] = INLINE {
RETURN[ Update[user, password, AddForward, individual, dest] ] };

AddMember: PROC[user: RName, password: Password, group: RName, member: RName] RETURNS[Outcome] = INLINE {
RETURN[ Update[user, password, AddMember, group, member] ] };

AddOwner: PROC[user: RName, password: Password, group: RName, owner: RName] RETURNS[Outcome] = INLINE {
RETURN[ Update[user, password, AddOwner, group, owner] ] };

AddFriend: PROC[user: RName, password: Password, group: RName, friend: RName] RETURNS[Outcome] = INLINE {
RETURN[ Update[user, password, AddFriend, group, friend] ] };



RemoveMailbox: PROC[user: RName, password: Password, individual: RName, site: RName] RETURNS[Outcome] = INLINE {
RETURN[ Update[user, password, DeleteMailBox, individual, site] ] };

RemoveForward: PROC[user: RName, password: Password, individual: RName, dest: RName] RETURNS[Outcome] = INLINE {
RETURN[ Update[user, password, DeleteForward, individual, dest] ] };

RemoveMember: PROC[user: RName, password: Password, group: RName, member: RName] RETURNS[Outcome] = INLINE {
RETURN[ Update[user, password, DeleteMember, group, member] ] };

RemoveOwner: PROC[user: RName, password: Password, group: RName, owner: RName] RETURNS[Outcome] = INLINE {
RETURN[ Update[user, password, DeleteOwner, group, owner] ] };

RemoveFriend: PROC[user: RName, password: Password, group: RName, friend: RName] RETURNS[Outcome] = INLINE {
RETURN[ Update[user, password, DeleteFriend, group, friend] ] };


Update: PROC[
user: RName,
password:  Password,
op: RSOperation,
target: RName,
value: GVBasics.GVString _ NIL,
newPwd: Password _ NULL,
list: RListHandle _ NIL,
reporter: ReporterProc _ NIL]
RETURNS[Outcome];

RSOperation: TYPE = MACHINE DEPENDENT {
NoOp(0),
Expand(1),
ReadMembers(2),
ReadOwners(3),
ReadFriends(4),
ReadEntry(5),
CheckStamp(6),
ReadConnect(7),
ReadRemark(8),
Authenticate(9),
CreateRegistry(10), -- not implemented
DeleteRegistry(11), -- not implemented
CreateIndividual(12),
DeleteIndividual(13),
CreateGroup(14),
DeleteGroup(15),
ChangePassword(16),
ChangeConnect(17),
ChangeRemark(18),
AddMember(19),
AddMailBox(20),
AddForward(21),
AddOwner(22),
AddFriend(23),
DeleteMember(24),
DeleteMailBox(25),
DeleteForward(26),
DeleteOwner(27),
DeleteFriend(28),
AddSelf(29),
DeleteSelf(30),
AddListOfMembers(31),
NewName(32),
IdentifyCaller(33),--internal to GVNamesImpl
IsMemberDirect(40), -- archaic
IsOwnerDirect(41), -- archaic
IsFriendDirect(42), -- archaic
IsMemberClosure(43), -- archaic
IsOwnerClosure(44), -- archaic
IsFriendClosure(45), -- archaic
IsInList(46),
ReadMailboxes(60), -- not implemented
(255)
};


ReporterProc: TYPE = PROC[ROPE];


SetServerInfo: TYPE = { badName, allDown, noRoute, ok };

SetServer: PROC[ROPE] RETURNS[ SetServerInfo ];

END.



€GVNames.mesa:  Client access to the R-Server database
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Andrew Birrell  June 22, 1983 5:58 pm
Levin, September 22, 1983 10:25 am
"RLists" are sequences of R-Names returned from the server
"Expand" returns mailbox site names for individuals, membership list for groups. If the old stamp is still current, returns "noChange".  Will not return "noChange" if the old stamp is defaulted.
"GetMembers" returns the membership list for a group. If the old stamp is still current, returns "noChange".  Will not return "noChange" if the old stamp is defaulted.
"CheckStamp" performs basic name validation, also telling the caller the name type. If the old stamp is still current, returns "noChange".  Will not return "noChange" if the old stamp is defaulted.
"GetConnect" returns the connect-site for an individual.  The connect-site is either an NLS name or a net-address.
"GetRemark" returns the remark for a group.  The remark is a human readable string..
"GetEntry" is mainly for use by Maintain.  It returns the entire contents of a database entry.  Consult a wizard before using GetEntry
"Authenticate" checks a user name and password.
Access control primitives
Updates
Creation and Deletion
Updates to single-valued components
Adding to list-valued components
Removing from list-valued components --
Enquiries (also 60..69)
Updates
60..69 reserved for more enquiries
"ReporterProc" is primarily to allow Maintain to report progress to its user.  Consult a wizard before using this facility.
"SetServer" provides a server hint, primarily used by Maintain.  Consult a wizard before using this facility.
ΚR˜
codešΟcœ
œ™5Kšœ
Οm
œ1™<Kš
œ%™%K™"—K˜š
Οk	˜	Kšœ	ŸœO˜]KšœŸœŸœ˜K˜—šœ	Ÿœ
Ÿœ
ŸœŸœ
Ÿœ˜>K˜šœ	Ÿœ&˜8Kšœ
$˜.Kšœ˜#Kšœ%˜+Kšœ˜%Kšœ
˜ K˜K˜—Kšœ
Ÿœ˜EK˜Kšœ
Ÿœ˜#šœŸœ˜%Kš
œ,˜,—K˜—š
œ:™:K˜KšœŸœ˜Kšœ
ŸœŸœ
Ÿœ˜"K˜—š
œΒ
™Β
K˜šœŸœŸœŸœ#Ÿ˜HKšœŸœ
˜˜ Kš
œ˜KšœŸœ˜
—˜#Kš
œ˜KšœŸœ˜
—KšœŸœ
˜KšœŸœ
˜KšœŸœ
˜KšœŸœ
˜KšŸœ˜
K˜—šΟnœŸœIŸœŸœ˜pK˜——š
Ϥ
™§
K˜šœŸœŸœŸœ#Ÿ˜HKšœŸœ
˜˜ Kš
œ˜KšœŸœ˜
—KšœŸœ
˜KšœŸœ
˜KšœŸœ
˜KšœŸœ
˜KšœŸœ
˜KšŸœ˜
K˜—š
 
œŸœ/ŸœŸœŸœ'˜Ž
K˜—š
 	œŸœ/ŸœŸœŸœ&˜Œ
K˜—Kš
 
œŸœ/ŸœŸœŸœ'˜Ž
K˜š œŸœLŸœŸœ
˜rK˜——š
œΕ
™Ε
K˜KšœŸœ˜.K˜š 
œŸœIŸœŸœ˜sK˜——šœXŸœ™rK˜Kšœ
Ÿœ˜-K˜š 
œŸœ'ŸœŸœ1˜tK˜——š
œT™TK˜KšœŸœ˜,K˜š 	œŸœ'Ÿœ
Ÿœ.˜pK˜——š
Ϡ
™†
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šœŸœ˜1K˜š œŸœŸœ
ŸœŸœŸœ8˜•
K˜—Kš œŸœ6Ÿœ
Ÿœ˜l
code2š œŸœŸœLŸœŸœ.Ÿœ˜Ξ
K˜——š
œ™K˜KšœŸœ"˜2š œŸœŸœŸœ
˜QKšŸœ2˜8K˜—š 
œŸœŸœŸœ
˜OKšŸœ0˜6K˜—š œŸœŸœŸœ
˜QKšŸœ2˜8K˜—š œŸœŸœŸœ
˜RKšŸœ3˜9K˜—š œŸœŸœŸœ
˜PKšŸœ1˜7K˜—š œ
ŸœŸœŸœ
˜QKšŸœ3˜9K˜—š œ
ŸœŸœŸœ
˜QKšŸœ3˜9K˜—š œŸœŸœŸœ
˜PKšŸœ1˜7K˜—š œ
ŸœŸœŸœ
˜QKšŸœ3˜9—K˜KšœŸœŸœ
Ÿ	œ'˜PKšœŸœŸœ
Ÿ	œ˜CKšœ
ŸœŸœ
Ÿ	œ'˜IK˜š œŸœuŸœ
Ÿœ
˜œ
K˜——Kš
œ™K˜K˜š
œ™K˜š œŸœGŸœŸœŸœ7Ÿœ˜Θ
K˜—š
 œŸœ5ŸœŸœŸœ;˜¨
K˜—š œŸœ0ŸœŸœ
˜\KšŸœ1˜7K˜—š œŸœ0ŸœŸœ
˜\KšŸœ3˜9K˜——š
œ#™#K˜š œŸœGŸœŸœ
˜sKšŸœ5Ÿœ˜LK˜—š 
œŸœPŸœŸœ
˜{KšŸœA˜GK˜—š 	œŸœIŸœŸœ˜sKšŸœ:˜@K˜——š
œ ™ K˜š 
œŸœBŸœŸœ
˜mKšŸœ;˜AK˜—š 
œŸœBŸœŸœ
˜mKšŸœ;˜AK˜—š 	œŸœ?ŸœŸœ
˜iKšŸœ7˜=K˜—š œŸœ>ŸœŸœ
˜gKšŸœ5˜;K˜—š 	œŸœ?ŸœŸœ
˜iKšŸœ7˜=K˜K˜——š
œ'™'K˜š 
œŸœBŸœŸœ
˜pKšŸœ>˜DK˜—š 
œŸœBŸœŸœ
˜pKšŸœ>˜DK˜—š œŸœ?ŸœŸœ
˜lKšŸœ:˜@K˜—š œŸœ>ŸœŸœ
˜jKšŸœ8˜>K˜—š œŸœ?ŸœŸœ
˜lKšŸœ:˜@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š
œ˜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šœ
˜Kš
œ
˜
—š
œ"™"Kšœ˜%—Kš
œ˜K˜K˜——š
œ{™{K˜Kš œŸœŸœ
Ÿœ˜ K˜—š
œm™mK˜KšœŸœ%˜8K˜š 	œŸœ
ŸœŸœ˜/K˜——KšŸœ
˜K˜K˜K˜—…—% 7r