DIRECTORY
BasicTime USING [GMT, Now, Period],
Convert USING [RopeFromTime],
IO USING [Flush, PutFR, PutRope, STREAM],
Rope USING [Cat, Equal, ROPE],
IPConfig USING[rootServers],
IPDefs USING [Address],
IPName USING [AddressToRope, LoadCacheFromName],
IPNameSupport,
IPNameCache USING [AddressEntry, AliasEntry, BogusAddressEntry, BogusNameEntry, DownAddressEntry, DownNameEntry, DownServerEntry, NameEntry, MXEntry, MXHostInfo, ZoneEntry],
ViewerIO USING [CreateViewerStreams, GetViewerFromStream];

IPNameSupportImpl: CEDAR MONITOR
IMPORTS BasicTime, Convert, IO, Rope, IPName, IPConfig, ViewerIO
EXPORTS IPNameSupport =
BEGIN

ROPE: TYPE = Rope.ROPE;

theLog: IO.STREAM;


LogRope: PUBLIC PROC [rope: ROPE] ~ {
putRope: PROC [stream: IO.STREAM] ~ { IO.PutRope[stream, rope] };
LogItem[putRope];
};

LogItem: ENTRY PROC [put: PROC [IO.STREAM]] ~ { put[theLog]; IO.Flush[theLog] };


NameSummaryLine: PUBLIC PROC [entry: IPNameCache.NameEntry, time: BOOLEAN, showttl: BOOLEAN _ FALSE, log: PROC[ROPE] _ LogRope] = {
now: BasicTime.GMT _ BasicTime.Now[];
expires: INT _ BasicTime.Period[from: now, to: entry.expires];
ttl: INT _ entry.ttl;
source: ROPE _ IPName.AddressToRope[entry.source];
line: ROPE;
Put: PROC [r1, r2, r3, r4: ROPE _ NIL] = {line _ Rope.Cat[line, r1, r2, r3, r4]};

IF time THEN {
Put[Convert.RopeFromTime[from: now, start: hours, end: seconds, useAMPM: FALSE, includeZone: FALSE]];
Put["  "];
};

Put[entry.name];
IF entry.addresses # NIL THEN Put[" => "];
FOR list: LIST OF IPDefs.Address _ entry.addresses, list.rest UNTIL list = NIL DO
IF list # entry.addresses THEN Put[", "];
Put[IPName.AddressToRope[list.first]];
ENDLOOP;
Put[IO.PutFR[", %G", [integer[expires]]]];
IF showttl THEN Put[IO.PutFR[", %G", [integer[ttl]]]];
Put[IO.PutFR[", %G", [rope[source]]]];
IF ~entry.authoritative THEN Put[", Not Auth"];
Put["\n"]; 
log[line]};

MXSummaryLine: PUBLIC PROC [entry: IPNameCache.MXEntry, time: BOOLEAN, showttl: BOOLEAN _ FALSE, log: PROC[ROPE] _ LogRope] = {
now: BasicTime.GMT _ BasicTime.Now[];
expires: INT _ BasicTime.Period[from: now, to: entry.expires];
ttl: INT _ entry.ttl;
source: ROPE _ IPName.AddressToRope[entry.source];
line: ROPE;
Put: PROC [r1, r2, r3, r4: ROPE _ NIL] = {line _ Rope.Cat[line, r1, r2, r3, r4]};

IF time THEN {
Put[Convert.RopeFromTime[from: now, start: hours, end: seconds, useAMPM: FALSE, includeZone: FALSE]];
Put["  "];
};

Put[entry.name];
IF entry.mxHosts # NIL THEN Put[" => "];

FOR list: LIST OF IPNameCache.MXHostInfo _ entry.mxHosts, list.rest UNTIL list = NIL DO
IF list # entry.mxHosts THEN Put["                    "];
Put[list.first.host];
Put[IO.PutFR[", MXP: %G", [integer[list.first.preference]]]];
Put[IO.PutFR[", %G", [integer[expires]]]];
IF showttl THEN Put[IO.PutFR[", %G", [integer[ttl]]]];
Put[IO.PutFR[", %G", [rope[source]]]];
IF ~entry.authoritative THEN Put[", Not Auth"];
Put["\n"]; 
ENDLOOP;
log[line]};


AliasSummaryLine: PUBLIC PROC [entry: IPNameCache.AliasEntry, time: BOOLEAN, showttl: BOOLEAN _ FALSE, log: PROC[ROPE] _ LogRope] = {
now: BasicTime.GMT _ BasicTime.Now[];
expires: INT _ BasicTime.Period[from: now, to: entry.expires];
ttl: INT _ entry.ttl;
source: ROPE _ IPName.AddressToRope[entry.source];
line: ROPE;
Put: PROC [r1, r2, r3, r4: ROPE _ NIL] = {line _ Rope.Cat[line, r1, r2, r3, r4]};

IF time THEN {
Put[Convert.RopeFromTime[from: now, start: hours, end: seconds, useAMPM: FALSE, includeZone: FALSE]];
Put["  "]};

Put[entry.alias];
Put[" => "];
Put[entry.name];

Put[IO.PutFR[", %G", [integer[expires]]]];
IF showttl THEN Put[IO.PutFR[", %G", [integer[ttl]]]];
Put[IO.PutFR[", %G", [rope[source]]]];
IF ~entry.authoritative THEN Put[", Not Auth"];
Put["\n"]; 
log[line]};



BogusNameSummaryLine: PUBLIC PROC [entry: IPNameCache.BogusNameEntry, time: BOOLEAN, showttl: BOOLEAN _ FALSE, log: PROC[ROPE] _ LogRope] = {
now: BasicTime.GMT _ BasicTime.Now[];
expires: INT _ BasicTime.Period[from: now, to: entry.expires];
ttl: INT _ entry.ttl;
source: ROPE _ IPName.AddressToRope[entry.source];
line: ROPE;
Put: PROC [r1, r2, r3, r4: ROPE _ NIL] = {line _ Rope.Cat[line, r1, r2, r3, r4]};

IF time THEN {
Put[Convert.RopeFromTime[from: now, start: hours, end: seconds, useAMPM: FALSE, includeZone: FALSE]];
Put["  "]};

Put[entry.bogus];
Put[IO.PutFR[ " => ??, %G", [integer[expires]]]];
IF showttl THEN Put[IO.PutFR[", %G", [integer[ttl]]]];
Put[IO.PutFR[", %G", [rope[source]]]];
IF ~entry.authoritative THEN Put[", Not Auth"];
Put["\n"]; 
log[line]};

DownNameSummaryLine: PUBLIC PROC [entry: IPNameCache.DownNameEntry, time: BOOLEAN, showttl: BOOLEAN _ FALSE, log: PROC[ROPE] _ LogRope] = {
now: BasicTime.GMT _ BasicTime.Now[];
expires: INT _ BasicTime.Period[from: now, to: entry.expires];
ttl: INT _ entry.ttl;
line: ROPE;
Put: PROC [r1, r2, r3, r4: ROPE _ NIL] = {line _ Rope.Cat[line, r1, r2, r3, r4]};
IF time THEN {
Put[Convert.RopeFromTime[from: now, start: hours, end: seconds, useAMPM: FALSE, includeZone: FALSE]];
Put["  "]};

Put[entry.name];
Put[IO.PutFR[ " => ??, %G", [integer[expires]]]];
IF showttl THEN Put[IO.PutFR[ ", %G", [integer[ttl]]]];
Put["\n"]; 
log[line]};

AddressSummaryLine: PUBLIC PROC [entry: IPNameCache.AddressEntry, time: BOOLEAN, showttl: BOOLEAN _ FALSE, log: PROC[ROPE] _ LogRope] = {
now: BasicTime.GMT _ BasicTime.Now[];
expires: INT _ BasicTime.Period[from: now, to: entry.expires];
ttl: INT _ entry.ttl;
source: ROPE _ IPName.AddressToRope[entry.source];
line: ROPE;
Put: PROC [r1, r2, r3, r4: ROPE _ NIL] = {line _ Rope.Cat[line, r1, r2, r3, r4]};
IF time THEN {
Put[Convert.RopeFromTime[from: now, start: hours, end: seconds, useAMPM: FALSE, includeZone: FALSE]];
Put["  "]};

Put[IPName.AddressToRope[entry.address]];
Put[" => "];
FOR list: LIST OF ROPE _ entry.names, list.rest UNTIL list = NIL DO
IF list # entry.names THEN Put[", "];
Put[list.first];
ENDLOOP;
Put[IO.PutFR[ ", %G", [integer[expires]]]];
IF showttl THEN Put[IO.PutFR[ ", %G", [integer[ttl]]]];
Put[IO.PutFR[ ", %G", [rope[source]]]];
IF ~entry.authoritative THEN Put[", Not Auth"];
Put["\n"]; 
log[line]};

BogusAddressSummaryLine: PUBLIC PROC [entry: IPNameCache.BogusAddressEntry, time: BOOLEAN, showttl: BOOLEAN _ FALSE, log: PROC[ROPE] _ LogRope] = {
now: BasicTime.GMT _ BasicTime.Now[];
expires: INT _ BasicTime.Period[from: now, to: entry.expires];
ttl: INT _ entry.ttl;
source: ROPE _ IPName.AddressToRope[entry.source];
line: ROPE;
Put: PROC [r1, r2, r3, r4: ROPE _ NIL] = {line _ Rope.Cat[line, r1, r2, r3, r4]};
IF time THEN {
Put[Convert.RopeFromTime[from: now, start: hours, end: seconds, useAMPM: FALSE, includeZone: FALSE]];
Put["  "]};

Put[IPName.AddressToRope[entry.bogus]];
Put[IO.PutFR[ " => ??, %G", [integer[expires]]]];
IF showttl THEN Put[IO.PutFR[ ", %G", [integer[ttl]]]];
IF ~entry.authoritative THEN Put[", Not Auth"];
Put["\n"]; 
log[line]};

DownAddressSummaryLine: PUBLIC PROC [entry: IPNameCache.DownAddressEntry, time: BOOLEAN, showttl: BOOLEAN _ FALSE, log: PROC[ROPE] _ LogRope] = {
now: BasicTime.GMT _ BasicTime.Now[];
expires: INT _ BasicTime.Period[from: now, to: entry.expires];
ttl: INT _ entry.ttl;
line: ROPE;
Put: PROC [r1, r2, r3, r4: ROPE _ NIL] = {line _ Rope.Cat[line, r1, r2, r3, r4]};
IF time THEN {
Put[Convert.RopeFromTime[from: now, start: hours, end: seconds, useAMPM: FALSE, includeZone: FALSE]];
Put["  "]};

Put[IPName.AddressToRope[entry.address]];
Put[IO.PutFR[ " => ??, %G", [integer[expires]]]];
IF showttl THEN Put[IO.PutFR[ ", %G", [integer[ttl]]]];
Put["\n"]; 
log[line]};


DownServerSummaryLine: PUBLIC PROC [entry: IPNameCache.DownServerEntry, time: BOOLEAN, showttl: BOOLEAN _ FALSE, log: PROC[ROPE] _ LogRope] = {
now: BasicTime.GMT _ BasicTime.Now[];
expires: INT _ BasicTime.Period[from: now, to: entry.expires];
ttl: INT _ entry.ttl;
line: ROPE;
Put: PROC [r1, r2, r3, r4: ROPE _ NIL] = {line _ Rope.Cat[line, r1, r2, r3, r4]};
IF time THEN {
Put[Convert.RopeFromTime[from: now, start: hours, end: seconds, useAMPM: FALSE, includeZone: FALSE]];
Put["  "]};

Put[IPName.AddressToRope[entry.address]];
Put[IO.PutFR[ " => ??, %G", [integer[expires]]]];
IF showttl THEN Put[IO.PutFR[ ", %G", [integer[ttl]]]];
Put["\n"]; 
log[line]};







ZoneSummaryLine: PUBLIC PROC [entry: IPNameCache.ZoneEntry, time: BOOLEAN, showttl: BOOLEAN _ FALSE, log: PROC[ROPE] _ LogRope] = {
now: BasicTime.GMT _ BasicTime.Now[];
expires: INT _ BasicTime.Period[from: now, to: entry.expires];
ttl: INT _ entry.ttl;
source: ROPE _ IPName.AddressToRope[entry.source];
line: ROPE;
Put: PROC [r1, r2, r3, r4: ROPE _ NIL] = {line _ Rope.Cat[line, r1, r2, r3, r4]};
IF time THEN {
Put[Convert.RopeFromTime[from: now, start: hours, end: seconds, useAMPM: FALSE, includeZone: FALSE]];
Put["  "]};

Put[entry.zone];
Put[" is served by "];
FOR list: LIST OF ROPE _ entry.servers, list.rest UNTIL list = NIL DO
IF list # entry.servers THEN Put[", "];
Put[list.first];
ENDLOOP;
Put[IO.PutFR[ ", %G", [integer[expires]]]];
IF showttl THEN Put[IO.PutFR[ ", %G", [integer[ttl]]]];
Put[IO.PutFR[ ", %G", [rope[source]]]];
IF ~entry.authoritative THEN Put[", Not Auth"];
Put["\n"]; 
log[line]};




RopeInList: PUBLIC PROC [ropes: LIST OF ROPE, rope: ROPE]
RETURNS [yes: BOOL] = {
FOR list: LIST OF ROPE _ ropes, list.rest UNTIL list = NIL DO
IF Rope.Equal[list.first, rope, FALSE] THEN RETURN [TRUE];
ENDLOOP;
RETURN[FALSE]; };

AddressInList: PUBLIC PROC [addresses: LIST OF IPDefs.Address, address: IPDefs.Address]
RETURNS [yes: BOOL] = {
FOR list: LIST OF IPDefs.Address _ addresses, list.rest UNTIL list = NIL DO
IF list.first = address THEN RETURN [TRUE];
ENDLOOP;
RETURN[FALSE]; };



MakeRopeInList: PUBLIC PROC [ropes: LIST OF ROPE, name: ROPE]
RETURNS [new: LIST OF ROPE] = {
IF ropes = NIL THEN RETURN[LIST[name]];
new _ ropes;
DO
IF Rope.Equal[ropes.first, name, FALSE] THEN RETURN;
IF ropes.rest = NIL THEN { ropes.rest _ LIST[name]; RETURN; };
ropes _ ropes.rest;
ENDLOOP; };

MakeAddressInList: PUBLIC PROC [addresses: LIST OF IPDefs.Address, address: IPDefs.Address]
RETURNS [new: LIST OF IPDefs.Address] = {
IF addresses = NIL THEN RETURN[LIST[address]];
new _ addresses;
DO
IF addresses.first = address THEN RETURN;
IF addresses.rest = NIL THEN { addresses.rest _ LIST[address]; RETURN; };
addresses _ addresses.rest;
ENDLOOP; };



[, theLog] _ ViewerIO.CreateViewerStreams [
name: "Resolver Log", backingFile: "Resolver.log", editedStream: FALSE];

ViewerIO.GetViewerFromStream[theLog].inhibitDestroy _ TRUE;

theLog.PutRope["########## ArpaGateway Resolver Log ##########\n\n"];



FOR servers: LIST OF Rope.ROPE _ IPConfig.rootServers, servers.rest UNTIL servers = NIL DO
[] _ IPName.LoadCacheFromName[servers.first, FALSE, TRUE];
ENDLOOP;

END.




ςIPNameSupportImpl.mesa
Copyright c 1986 by Xerox Corporation.  All rights reserved.
John Larson, July 26, 1987 3:17:39 pm PDT 
Resolver log support routines
Misc support routines
Set up the name resolver log

Load root server addresses
ΚN˜š
œ™Icodešœ
Οm
œ1™<K™*—J˜š
Οk	˜	Jšœ
žœžœ˜#Jšœžœ˜Jšžœ
žœžœ˜)Jšœžœžœ˜Jšœ	žœ˜Jšœžœ˜Jšœžœ$˜0Jš
œ˜Jšœžœœ
˜­
šœ	žœ,˜:J˜——šΟnœžœ
ž˜ Jšžœžœ"˜@Jšžœ˜Jš
ž˜J˜Jšžœžœžœ
˜J˜Jšœžœ
žœ
˜J˜J™J˜
unitšŸœžœ
žœžœ˜%Kšœ	žœ
ž	œ!˜AKš
œ˜Kš
œ˜K˜—JšŸœžœ
žœžœž	œžœ˜P˜J˜—šΠbnœžœ
žœ&žœžœžœžœ
žœ˜ƒ
Jšœžœ˜%Jšœ	žœ2˜>Jšœžœ
˜Jšœžœ&˜2Jšœžœ
˜JšŸœžœžœžœ,˜QJ˜šžœžœ˜Icode2šœIžœžœ˜eMš
œ
˜
Mš
œ˜—J˜Jš
œ˜Jšžœžœ
žœ
˜*šžœžœ
žœ-žœžœ
ž˜QJšžœžœ˜)Jš
œ&˜&Jšžœ
˜—Jšœžœ$˜*Jšžœ	žœžœ ˜6Jšœžœ ˜&Jšžœžœ˜/Jš
œ˜Jš
œ˜J˜—š 
œžœ
žœ$žœžœžœžœ
žœ˜Jšœžœ˜%Jšœ	žœ2˜>Jšœžœ
˜Jšœžœ&˜2Jšœžœ
˜JšŸœžœžœžœ,˜QJ˜šžœžœ˜MšœIžœžœ˜eMš
œ
˜
Mš
œ˜—J˜Jš
œ˜Jšžœžœ
žœ
˜(J˜šžœžœ
žœ3žœžœ
ž˜WJšžœžœ˜9Jš
œ˜Jšœžœ7˜=Jšœžœ$˜*Jšžœ	žœžœ ˜6Jšœžœ ˜&Jšžœžœ˜/Jš
œ˜Jšžœ
˜—Jš
œ˜J˜J˜—š œžœ
žœ'žœžœžœžœ
žœ˜…
Jšœžœ˜%Jšœ	žœ2˜>Jšœžœ
˜Jšœžœ&˜2Jšœžœ
˜JšŸœžœžœžœ,˜QJ˜šžœžœ˜MšœIžœžœ˜eMš
œ˜—J˜Jš
œ˜Jš
œ˜Jš
œ˜J˜Jšœžœ$˜*Jšžœ	žœžœ ˜6Jšœžœ ˜&Jšžœžœ˜/Jš
œ˜Jš
œ˜J˜J˜J˜—š œžœ
žœ+žœžœžœžœ
žœ˜
Jšœžœ˜%Jšœ	žœ2˜>Jšœžœ
˜Jšœžœ&˜2Jšœžœ
˜JšŸœžœžœžœ,˜QJ˜šžœžœ˜MšœIžœžœ˜eMš
œ˜M˜—Jš
œ˜Jšœžœ+˜1Jšžœ	žœžœ ˜6Jšœžœ ˜&Jšžœžœ˜/Jš
œ˜Jš
œ˜J˜—š œžœ
žœ*žœžœžœžœ
žœ˜‹
Jšœžœ˜%Jšœ	žœ2˜>Jšœžœ
˜Jšœžœ
˜JšŸœžœžœžœ,˜Qšžœžœ˜MšœIžœžœ˜eMš
œ˜M˜—Jš
œ˜Jšœžœ+˜1Jšžœ	žœžœ!˜7Jš
œ˜Jš
œ˜J˜—š œžœ
žœ)žœžœžœžœ
žœ˜‰
Jšœžœ˜%Jšœ	žœ2˜>Jšœžœ
˜Jšœžœ&˜2Jšœžœ
˜JšŸœžœžœžœ,˜Qšžœžœ˜MšœIžœžœ˜eMš
œ˜M˜—Jš
œ)˜)Jš
œ˜š
žœžœ
žœ
žœžœžœ
ž˜CJšžœžœ˜%Jš
œ˜Jšžœ
˜—Jšœžœ%˜+Jšžœ	žœžœ!˜7Jšœžœ!˜'Jšžœžœ˜/Jš
œ˜Jš
œ˜J˜—š œžœ
žœ.žœžœžœžœ
žœ˜“
Jšœžœ˜%Jšœ	žœ2˜>Jšœžœ
˜Jšœžœ&˜2Jšœžœ
˜JšŸœžœžœžœ,˜Qšžœžœ˜MšœIžœžœ˜eMš
œ˜M˜—Jš
œ'˜'Jšœžœ+˜1Jšžœ	žœžœ!˜7Jšžœžœ˜/Jš
œ˜Jš
œ˜J˜—š œžœ
žœ-žœžœžœžœ
žœ˜‘
Jšœžœ˜%Jšœ	žœ2˜>Jšœžœ
˜Jšœžœ
˜JšŸœžœžœžœ,˜Qšžœžœ˜MšœIžœžœ˜eMš
œ˜M˜—Jš
œ)˜)Jšœžœ+˜1Jšžœ	žœžœ!˜7Jš
œ˜Jš
œ˜J˜J˜—š œžœ
žœ,žœžœžœžœ
žœ˜
Jšœžœ˜%Jšœ	žœ2˜>Jšœžœ
˜Jšœžœ
˜JšŸœžœžœžœ,˜Qšžœžœ˜MšœIžœžœ˜eMš
œ˜M˜—Jš
œ)˜)Jšœžœ+˜1Jšžœ	žœžœ!˜7Jš
œ˜Jš
œ˜J˜J˜J˜J˜J˜J˜J˜—š œžœ
žœ&žœžœžœžœ
žœ˜ƒ
Jšœžœ˜%Jšœ	žœ2˜>Jšœžœ
˜Jšœžœ&˜2Jšœžœ
˜JšŸœžœžœžœ,˜Qšžœžœ˜MšœIžœžœ˜eMš
œ˜M˜—Jš
œ˜Jš
œ˜š
žœžœ
žœ
žœžœžœ
ž˜EJšžœžœ˜'Jš
œ˜Jšžœ
˜—Jšœžœ%˜+Jšžœ	žœžœ!˜7Jšœžœ!˜'Jšžœžœ˜/Jš
œ˜Jš
œ˜J˜J˜—š
œ™J˜J˜—šŸ
œžœ
žœ	žœ
žœ
žœžœ
˜9Jšžœžœ˜š
žœžœ
žœ
žœžœžœ
ž˜=Jš
žœžœžœ
žœžœ˜:Jšžœ
˜—Jšžœ
žœ˜J˜—š
Ÿ
œžœ
žœ
žœ
žœ)˜WJšžœžœ˜šžœžœ
žœ'žœžœ
ž˜KJšžœžœ
žœžœ˜+Jšžœ
˜—Jšžœ
žœ˜J˜˜J˜——šŸœžœ
žœ	žœ
žœ
žœžœ
˜=Jšžœžœ
žœ
žœ˜Jš
žœ	žœ
žœ
žœ
žœ˜'Jš
œ˜š
ž˜Jšžœžœžœ
žœ
˜4Jš
žœžœ
žœžœžœ˜>J˜Jšžœ˜J˜——š
Ÿœžœ
žœ
žœ
žœ)˜[Jšžœžœ
žœ˜)Jš
žœ
žœ
žœ
žœ
žœ˜.Jš
œ˜š
ž˜Jšžœžœ
žœ
˜)Jš
žœžœ
žœžœžœ˜IJš
œ˜Jšžœ˜J˜J˜—J˜Jš
œ™J™š
œ+˜+JšœAžœ˜HJ˜—Jšœ6žœ
˜;J˜Jš
œE˜EJ˜J˜Jš
œ™J˜š
žœ
žœ
žœžœ&žœžœ
ž˜ZJšœ-žœžœ˜:Jšžœ
˜—J˜—Jšžœ
˜J˜J˜J˜—J˜—…—)Ž8Ξ