-- Copyright (C) 1984 by Xerox Corporation. All rights reserved.
-- PupDirServerNoDisk.mesa, HGM, 9-May-86 16:14:21
-- We don't have a copy of the file, but we keep a BIG cache of things we find
-- on other servers so we can pass the service on to clients on adjacent nets.
-- This module watches the directory version on the net, and flushes the cache
-- so it will get reloaded with current information.
-- It also "forwards" netDirVersion requests aka the Pup boot servers to keep IFSs happy.
DIRECTORY
Ascii USING [CR],
CmFile USING [Handle, TableError],
Heap USING [systemZone],
Process USING [Detach, SetTimeout, MsecToTicks],
Put USING [Text],
String USING [AppendChar, AppendNumber, AppendString, AppendDecimal],
StringLookUp USING [noMatch],
Time USING [AppendCurrent],
Token USING [FreeTokenString, Item, Octal],
Buffer USING [AccessHandle, DestroyPool, GetBuffer, MakePool, ReturnBuffer],
Indirect USING [Close, NextValue, OpenSection],
MiscServerDefs USING [PupMiscServerOn, SetDirectoryServer],
NameServerDefs USING [
lockDirRequest, lockDirReply, unlockDirRequest, unlockDirReply,
FlushWholeCache, PupNameServerOn, BumpCacheSize],
PupDefs USING [
AppendHostName, GetPupAddress, GetPupContentsBytes, PupBuffer, PupNameTrouble,
PupRouterBroadcastThis, PupRouterSendThis, PupSocket, PupSocketDestroy, PupSocketID,
PupSocketMake, SecondsToTocks, SetPupContentsWords,
ReturnPup, UniqueLocalPupSocketID],
PupRouterDefs USING [NetworkContext],
PupTypes USING [fillInPupAddress, miscSrvSoc, PupAddress, PupNetID],
Stats USING [StatCounterIndex, StatIncr];
PupDirServerNoDisk: MONITOR
IMPORTS
CmFile, Heap, Process, Put, String, Time, Token,
Buffer, Indirect, MiscServerDefs, NameServerDefs, PupDefs, Stats
EXPORTS NameServerDefs =
BEGIN OPEN Stats, NameServerDefs, PupDefs;
z: UNCOUNTED ZONE = Heap.systemZone;
remote: Chain ← NIL;
Chain: TYPE = LONG POINTER TO ChainSlot;
ChainSlot: TYPE = RECORD [
next: Chain,
source: PupTypes.PupNetID,
dest: PupTypes.PupAddress,
target: LONG STRING];
dirRunning, probing, sending: PUBLIC BOOLEAN ← FALSE;
useCount: CARDINAL ← 0;
pleaseStop: BOOLEAN ← FALSE;
probePeriod: CARDINAL ← 60; -- in minutes
tries: CARDINAL ← 0;
delay: CONDITION;
lock: BOOLEAN ← FALSE;
verbose: BOOLEAN = TRUE;
currentVersion: CARDINAL ← 0;
oldVersionAround: BOOLEAN ← TRUE;
fileName: STRING = "Pup-network.directory";
statVers, statSend: PUBLIC StatCounterIndex;
GetNewDirectoryVersion, GetOldDirectoryVersion: PUBLIC PROCEDURE RETURNS [CARDINAL, BOOLEAN] =
BEGIN RETURN[currentVersion, FALSE]; END;
PupDirServerOn: PUBLIC PROCEDURE =
BEGIN
IF (useCount ← useCount + 1) = 1 THEN
BEGIN
dirRunning ← TRUE;
Starter[];
END;
END;
Starter: PROCEDURE =
BEGIN
pleaseStop ← FALSE;
MiscServerDefs.PupMiscServerOn[];
ScanParameterFile[];
MiscServerDefs.SetDirectoryServer[PupDirServer];
Process.Detach[FORK ProbeGovenor[]];
END;
CountTries: ENTRY PROCEDURE = BEGIN tries ← tries + 1; END;
KickProber: PUBLIC ENTRY PROCEDURE =
BEGIN IF tries > 3 THEN RETURN; StartProbing[]; END;
StartProbingForDirectory: PUBLIC ENTRY PROCEDURE = BEGIN StartProbing[]; END;
StartProbing: INTERNAL PROCEDURE =
BEGIN
IF pleaseStop OR probing THEN RETURN;
probing ← TRUE;
Process.Detach[FORK Probe[]];
END;
ProbeGovenor: ENTRY PROCEDURE =
BEGIN
n: CARDINAL ← 1; -- probe 1 min after startup
Process.SetTimeout[@delay, Process.MsecToTicks[60000]];
UNTIL pleaseStop DO
WAIT delay; -- one minute
IF probing THEN BEGIN n ← probePeriod; LOOP; END;
IF (n ← n - 1) = 0 THEN
BEGIN
tries ← 0;
StartProbing[];
WHILE probing DO WAIT delay; ENDLOOP;
n ← probePeriod;
END;
ENDLOOP;
END;
Probe: PROCEDURE =
BEGIN
b: PupBuffer;
from: PupSocketID ← UniqueLocalPupSocketID[];
pool: Buffer.AccessHandle;
soc: PupSocket;
bestSoFar: CARDINAL;
where: PupTypes.PupAddress;
sawOldVersion: BOOLEAN ← FALSE;
bestSoFar ← currentVersion;
pool ← Buffer.MakePool[send: 1, receive: 10];
soc ← PupSocketMake[from, PupTypes.fillInPupAddress, SecondsToTocks[1]];
THROUGH [0..5) UNTIL bestSoFar > currentVersion DO
b ← Buffer.GetBuffer[pup, pool, send];
b.pup.source.socket ← from;
b.pup.dest.socket ← PupTypes.miscSrvSoc;
b.pup.pupType ← netDirVersion;
b.pup.pupWords[0] ← 0;
b.pup.pupWords[1] ← 0;
SetPupContentsWords[b, 2];
PupRouterBroadcastThis[b];
UNTIL b = NIL DO
b ← soc.get[];
IF b # NIL THEN
BEGIN
IF b.pup.pupType = netDirVersion THEN
BEGIN
SELECT b.pup.pupWords[0] FROM
> bestSoFar =>
BEGIN bestSoFar ← b.pup.pupWords[0]; where ← b.pup.source; END;
< currentVersion => sawOldVersion ← TRUE;
ENDCASE => NULL;
IF GetPupContentsBytes[b] > 2 THEN
BEGIN
SELECT b.pup.pupWords[1] FROM
> bestSoFar =>
BEGIN bestSoFar ← b.pup.pupWords[0]; where ← b.pup.source; END;
< currentVersion => sawOldVersion ← TRUE;
ENDCASE => NULL;
END;
END;
Buffer.ReturnBuffer[b];
END;
ENDLOOP;
ENDLOOP;
PupSocketDestroy[soc];
Buffer.DestroyPool[pool];
IF bestSoFar > currentVersion THEN
BEGIN
IF verbose THEN
BEGIN OPEN String;
text: STRING = [100];
Time.AppendCurrent[text];
AppendString[text, " Saw "L];
AppendString[text, fileName];
AppendString[text, "!"L];
AppendDecimal[text, bestSoFar];
AppendString[text, " on "L];
AppendHostName[text, where];
LogString[text];
END;
FlushWholeCache[];
currentVersion ← bestSoFar;
probing ← FALSE;
RETURN;
END;
IF sawOldVersion OR oldVersionAround THEN
BEGIN
oldVersionAround ← sawOldVersion;
FlushWholeCache[];
END;
probing ← FALSE;
END;
PupDirServer: PUBLIC PROCEDURE [b: PupBuffer] =
BEGIN
IF ~(lock OR pleaseStop) OR b.pup.pupType = unlockDirRequest THEN
SELECT b.pup.pupType FROM
netDirVersion =>
BEGIN
StatIncr[statVers];
SELECT b.pup.pupWords[0] FROM
= currentVersion => NULL; -- we have the same ones
> currentVersion => KickProber[]; -- he has a newer one
< currentVersion => NULL; -- Don't respond since we can't send it
ENDCASE => ERROR;
MaybeForwardThisOne[b];
RETURN;
END;
sendNetDir => NULL;
lockDirRequest =>
BEGIN
lock ← TRUE;
ReturnPup[b, lockDirReply, 0];
FlushWholeCache[];
RETURN;
END;
unlockDirRequest =>
BEGIN
wasLocked: BOOLEAN ← lock;
lock ← FALSE;
ReturnPup[b, unlockDirReply, 0];
tries ← 0;
KickProber[];
RETURN;
END;
ENDCASE;
Buffer.ReturnBuffer[b];
END;
MaybeForwardThisOne: PROCEDURE [b: PupDefs.PupBuffer] =
BEGIN
context: PupRouterDefs.NetworkContext = b.context;
IF b.pup.source.net = 0 THEN b.pup.source.net ← [context.pupNetNumber];
FOR finger: Chain ← remote, finger.next UNTIL finger = NIL DO
IF context.pupNetNumber = finger.source THEN
BEGIN
IF finger.dest = PupTypes.fillInPupAddress THEN EXIT;
b.pup.dest.net ← finger.dest.net;
b.pup.dest.host ← finger.dest.host;
PupDefs.PupRouterSendThis[b];
RETURN;
END;
ENDLOOP;
Buffer.ReturnBuffer[b];
END;
ScanParameterFile: PROCEDURE =
BEGIN
cmFile: CmFile.Handle;
Option: TYPE = {remote};
NextValue: PROCEDURE [
h: CmFile.Handle, table: LONG DESCRIPTOR FOR ARRAY Option OF LONG STRING]
RETURNS [Option] = LOOPHOLE[Indirect.NextValue];
optionTable: ARRAY Option OF LONG STRING ← [remote: "Remote"L];
cmFile ← Indirect.OpenSection["PupDirServer"L];
IF cmFile = NIL THEN RETURN;
DO
option: Option;
option ← NextValue[
cmFile, DESCRIPTOR[optionTable] !
CmFile.TableError =>
BEGIN
IF name[0] # '; THEN Message["Unrecognized parameter: ", name];
RETRY;
END];
SELECT option FROM
LOOPHOLE[StringLookUp.noMatch] => EXIT;
remote =>
BEGIN
source: PupTypes.PupNetID = [Token.Octal[cmFile]];
temp: LONG STRING ← Token.Item[cmFile, FALSE];
new: Chain ← z.NEW[ChainSlot];
new↑ ← [NIL, source, PupTypes.fillInPupAddress, z.NEW[StringBody[temp.length]]];
String.AppendString[new.target, temp];
[] ← Token.FreeTokenString[temp];
PupDefs.GetPupAddress[@new.dest, new.target ! PupDefs.PupNameTrouble => CONTINUE];
IF remote = NIL THEN remote ← new
ELSE
BEGIN
FOR finger: Chain ← remote, finger.next DO
IF finger.next = NIL THEN
BEGIN
finger.next ← new;
EXIT;
END;
ENDLOOP;
END;
MessageNet["Forwarding Pup NetDirVersion requests from net "L, new.source, " to "L, new.target];
END;
ENDCASE => ERROR;
ENDLOOP;
Indirect.Close[cmFile];
END;
MessageNet: PROCEDURE [one: LONG STRING, net: CARDINAL, three, four: LONG STRING] =
BEGIN
two: STRING = [20];
String.AppendNumber[two, net, 8];
Message[one, two, three, four];
END;
Message: PROCEDURE [one, two, three, four: LONG STRING ← NIL] =
BEGIN
text: STRING = [200];
String.AppendString[text, one];
IF two # NIL THEN String.AppendString[text, two];
IF three # NIL THEN String.AppendString[text, three];
IF four # NIL THEN String.AppendString[text, four];
LogString[text];
END;
LogString: PROCEDURE [text: LONG STRING] =
BEGIN
String.AppendChar[text, '.];
String.AppendChar[text, Ascii.CR];
Put.Text[NIL, text];
END;
-- initialization
PupDirServerOn[];
NameServerDefs.PupNameServerOn[];
NameServerDefs.BumpCacheSize[2000];
END.