DIRECTORY
BasicTime USING [GMT, Now, nullGMT, Pack, Unpack, Unpacked],
FS USING [Error, ErrorGroup, InfoProc, NameProc],
FSBackdoor USING [ErrorCode, ProduceError, Version],
FSName USING [BangStarFile, BangVersionFile, VersionFromRope],
FSPseudoServers USING [AvoidRemoteCheck, PseudoServerList, TranslateForRead, TranslateForWrite],
FSRemoteFile USING [ConfirmProc, Lookup, LookupResult],
FSReport USING [UnknownFile],
GVBasics USING [Connect],
GVNames USING [ConnectInfo, GetConnect],
IO USING [STREAM],
Process USING [CheckForAbort, Detach, Seconds, SecondsToTicks],
Rope USING [Cat, Concat, Equal, Fetch, Find, Flatten, Length, Match, ROPE],
RuntimeError USING [UNCAUGHT],
STP USING [Close, ConfirmProcType, Continue, Create, Delete, DesiredProperties, Enumerate, Error, ErrorCode, FileInfo, GetFileInfo, Handle, IsOpen, Login, NoteFileProcType, Open, Rename, Retrieve, SetDesiredProperties, SetDirectory, Store, ValidProperties],
UserCredentials USING [Get];
FSRemoteFileImpl: CEDAR MONITOR
IMPORTS BasicTime, FS, FSBackdoor, FSName, FSPseudoServers, FSRemoteFile, FSReport, GVNames, Process, Rope, RuntimeError, STP, UserCredentials
EXPORTS FSRemoteFile
= {

GMT: TYPE = BasicTime.GMT;
Handle: TYPE = STP.Handle;
ROPE: TYPE = Rope.ROPE;
PseudoServerList: TYPE = FSPseudoServers.PseudoServerList;
STREAM: TYPE = IO.STREAM;
Version: TYPE = FSBackdoor.Version;

Delete: PUBLIC PROC [server, file: ROPE, wantedCreatedTime: GMT, proc: FSRemoteFile.ConfirmProc] = {
Confirm: STP.ConfirmProcType = {
info: STP.FileInfo = STP.GetFileInfo[h];
created: GMT = FTPTimeToGMT[info.create];
SELECT TRUE FROM
matchFound => answer _ abort;
NOT timeSearch OR wantedCreatedTime = created => {
answer _ IF proc [FSName.VersionFromRope[info.version]] THEN do ELSE abort;
matchFound _ TRUE;
};
ENDCASE => answer _ skip;
};
matchFound: BOOLEAN _ FALSE;
timeSearch: BOOLEAN = (wantedCreatedTime # BasicTime.nullGMT);
stpCode: STP.ErrorCode _ noSuchFile;
h: Handle _ NIL;
innerDelete: PROC RETURNS [ok: BOOL _ TRUE] = {
tServer: ROPE _ FSPseudoServers.TranslateForWrite[UnbracketServer[server]];
h _ NIL;
{
ENABLE UNWIND => ReturnConnection[tServer, h];
h _ GetConnection[tServer, file, FALSE];
STP.Delete[h, file, Confirm
! STP.Error => IF code = noSuchFile THEN CONTINUE ];
IF NOT matchFound THEN {
IF timeSearch THEN {
file _ FSName.BangStarFile[file];
STP.Delete[h, file, Confirm];
};
IF NOT matchFound THEN {stpCode _ noSuchFile; RETURN [FALSE]};
};
};
ReturnConnection[tServer, h];
};
IF innerDelete[ ! STP.Error => {stpCode _ code; CONTINUE}] THEN RETURN;
ReportSTPError[stpCode, server, file, wantedCreatedTime];
};
EnumerateForInfo: PUBLIC PROC [server, pattern: ROPE, proc: FS.InfoProc] = {
NoteInfo: LocalEnumProc = {
info: STP.FileInfo = STP.GetFileInfo[h];
created: BasicTime.GMT = FTPTimeToGMT[info.create];
continue _ IF proc[Rope.Concat[serverB, file], NIL, created, info.size, 0]
THEN yes ELSE no;
};
serverB: ROPE = BracketServer[server];
InnerEnumerate[server, pattern, NoteInfo, FALSE];
};
EnumerateForNames: PUBLIC PROC [server, pattern: ROPE, proc: FS.NameProc] = {
NoteName: LocalEnumProc = {
continue _ IF proc[Rope.Concat[serverB, file]] THEN yes ELSE no;
};
serverB: ROPE = BracketServer[server];
InnerEnumerate[server, pattern, NoteName, TRUE];
};
LocalEnumProc: TYPE = PROC [h: Handle, file: ROPE] RETURNS [continue: STP.Continue];
InnerEnumerate: PUBLIC PROC [server, pattern: ROPE, Note: LocalEnumProc, namesOnly: BOOL] = {
stpCode: STP.ErrorCode _ noSuchFile;
h: Handle _ NIL;
notedOne: BOOL _ FALSE;
innerNote: STP.NoteFileProcType = {
Process.CheckForAbort[];
notedOne _ TRUE;
IF NOT Rope.Match["<*", file] THEN file _ Rope.Concat["<>", file];
continue _ Note[h, file];
};
innerBlock: PROC [eachName: ROPE] = {
h _ NIL;
{
ENABLE UNWIND => ReturnConnection[eachName, h];
h _ GetConnection[eachName, pattern, namesOnly];
STP.Enumerate[h, pattern, innerNote];
};
ReturnConnection[eachName, h];
};
serverList: LIST OF ROPE = FSPseudoServers.TranslateForRead[server];
replicated: BOOL = FSPseudoServers.AvoidRemoteCheck[server];
FOR each: LIST OF ROPE _ serverList, each.rest WHILE each # NIL DO
innerBlock[each.first
! STP.Error =>
SELECT TRUE FROM
code = noSuchFile =>
SELECT TRUE FROM
replicated, notedOne => GO TO NotFound;
ENDCASE => LOOP;
notedOne => {
stpCode _ code; EXIT};
each = serverList => {
stpCode _ code; LOOP};
ENDCASE =>
LOOP;
];
RETURN;
ENDLOOP;
IF stpCode # noSuchFile THEN ReportSTPError[stpCode, server, pattern, BasicTime.nullGMT];
EXITS NotFound => {};
};
Info: PUBLIC PROC [server, file: ROPE, wantedCreatedTime: GMT] RETURNS [version: Version, bytes: INT, created: GMT] = {
ReportError: PROC [stpCode: STP.ErrorCode] = {
ReportSTPError[stpCode, server, file, wantedCreatedTime];
};
result: FSRemoteFile.LookupResult;
serverList: LIST OF ROPE = FSPseudoServers.TranslateForRead[server];
replicated: BOOL = FSPseudoServers.AvoidRemoteCheck[server];
allDown: BOOL _ TRUE;
FOR each: LIST OF ROPE _ serverList, each.rest WHILE each # NIL DO
eachServer: ROPE _ each.first;
last: BOOL _ each.rest = NIL;
[result, version, created, bytes] _ FSRemoteFile.Lookup[eachServer, file];
IF result#noResponse THEN allDown _ FALSE;
SELECT result FROM
noSuchFile => {
IF NOT replicated THEN LOOP;
IF wantedCreatedTime = BasicTime.nullGMT THEN ReportError[noSuchFile];
EXIT;
};
ok => {
IF wantedCreatedTime = BasicTime.nullGMT THEN RETURN;
IF wantedCreatedTime = created THEN RETURN;
IF NOT replicated THEN LOOP;
EXIT};
ENDCASE;
ENDLOOP;
[version, bytes, created] _ STPInfo[server, file, wantedCreatedTime];
};
Rename: PUBLIC PROC [server, fromFile: ROPE, fromCreated: GMT, toFile: ROPE, proc: FSRemoteFile.ConfirmProc] = {
stpCode: STP.ErrorCode _ noSuchFile;
version: Version = Info[server, fromFile, fromCreated].version;
innerRename: PROC RETURNS [ok: BOOL _ TRUE] = {
h: Handle _ NIL;
tServer: ROPE _ FSPseudoServers.TranslateForWrite[server];
{
ENABLE UNWIND => ReturnConnection[tServer, h];
h _ GetConnection[tServer, fromFile, TRUE];
fromFile _ FSName.BangVersionFile[fromFile, version];
STP.Rename[h, fromFile, toFile];
};
ReturnConnection[tServer, h];
};
IF proc[version] THEN {
IF innerRename[! STP.Error => {stpCode _ code; CONTINUE}] THEN RETURN;
ReportSTPError[stpCode, server, toFile, BasicTime.nullGMT];
};
};
Retrieve: PUBLIC PROC [server, file: ROPE, wantedCreatedTime: GMT, proc: PROC[fullGName: ROPE, bytes: INT, created: GMT] RETURNS [STREAM]] = {
matchFound: BOOL _ FALSE;
timeSearch: BOOL = (wantedCreatedTime # BasicTime.nullGMT);
h: Handle _ NIL;
stpCode: STP.ErrorCode _ noSuchFile;
serverB: ROPE = BracketServer[server];
Confirm: STP.ConfirmProcType = {
info: STP.FileInfo = STP.GetFileInfo[h];
created: GMT = FTPTimeToGMT[info.create];
SELECT TRUE FROM
matchFound => answer _ abort;
NOT timeSearch OR wantedCreatedTime = created => {
localStream _ proc[Rope.Concat[serverB, file], info.size, created];
answer _ IF localStream = NIL THEN abort ELSE do;
matchFound _ TRUE;
};
ENDCASE => answer _ skip;
};
innerRetrieve: PROC [eachServer: ROPE] RETURNS [success: BOOL _ TRUE] = {
h _ NIL;
{
ENABLE UNWIND => ReturnConnection[eachServer, h];
h _ GetConnection[eachServer, file, FALSE];
STP.Retrieve[h, file, Confirm
! STP.Error => IF code = noSuchFile THEN CONTINUE ];
IF NOT matchFound THEN {
IF timeSearch THEN {
file _ FSName.BangStarFile[file];
STP.Retrieve[h, file, Confirm];
};
IF NOT matchFound THEN {stpCode _ noSuchFile; success _ FALSE};
};
};
ReturnConnection[eachServer, h];
};
serverList: LIST OF ROPE = FSPseudoServers.TranslateForRead[server];
replicated: BOOL = FSPseudoServers.AvoidRemoteCheck[server];
FOR each: LIST OF ROPE _ serverList, each.rest WHILE each # NIL DO
IF innerRetrieve[each.first
! STP.Error => {
IF each = serverList THEN stpCode _ code;
IF each.rest = NIL THEN EXIT;
IF stpCode = noSuchFile AND replicated THEN EXIT;
LOOP}
] THEN RETURN ELSE IF replicated THEN EXIT;
ENDLOOP;
ReportSTPError[stpCode, server, file, wantedCreatedTime];
};
Store: PUBLIC PROC [server, file: ROPE, str: STREAM, created: GMT, proc: FSRemoteFile.ConfirmProc] = {
h: Handle _ NIL;
Note: STP.NoteFileProcType = {
doIt: BOOL = proc [ FSName.VersionFromRope[ STP.GetFileInfo[h].version ] ];
continue _ IF doIt THEN yes ELSE no;
};
innerStore: PROC RETURNS [ok: BOOL _ TRUE] = {
tServer: ROPE _ FSPseudoServers.TranslateForWrite[server];
{
ENABLE UNWIND => ReturnConnection[tServer, h];
h _ GetConnection[tServer, file, TRUE];
STP.Store[h, file, str, Note, unknown, created];
};
ReturnConnection[tServer, h];
};
stpCode: STP.ErrorCode _ noSuchFile;
IF innerStore[ ! STP.Error => {stpCode _ code; CONTINUE}] THEN RETURN;
ReportSTPError[stpCode, server, file, BasicTime.nullGMT];
};
FTPTimeToGMT: PUBLIC PROC [t: Rope.ROPE] RETURNS [time: BasicTime.GMT _ BasicTime.nullGMT] = {
adjust: NAT _ 0;
Digit: PROC [index: INT] RETURNS [CARDINAL] = {
c: CHAR = Rope.Fetch[t, index-adjust];
SELECT c FROM
'  => RETURN [0];
IN ['0..'9] => RETURN [c-'0];
ENDCASE => ERROR BadTime;
};
DoubleDigit: PROC [index: INT] RETURNS [CARDINAL] = {
RETURN [Digit[index]*10 + Digit[index+1]];
};
Char: PROC [index: INT] RETURNS [CHAR] = {
c: CHAR = Rope.Fetch[t, index];
SELECT c FROM
'-, '+, ' , IN ['a..'z], IN ['0..'9] => RETURN [c];
IN ['A..'Z] => RETURN [c + ('a-'A)];
ENDCASE => ERROR BadTime;
};
Inner: PROC = {
uT: BasicTime.Unpacked;
yr: CARDINAL = DoubleDigit[7];
SELECT yr FROM
< 50 => uT.year _ yr + 2000;
ENDCASE => uT.year _ yr + 1900;
IF Char[1] IN ['0..'9]
THEN uT.day _ DoubleDigit[0]
ELSE {
uT.day _ Digit[0];
adjust _ 1};
uT.day _ DoubleDigit[0];
uT.hour _ DoubleDigit[10];
uT.minute _ DoubleDigit[13];
uT.second _ DoubleDigit[16];
uT.month _ SELECT Char[3] FROM
'j => IF Char[4] = 'a THEN January ELSE IF Char[5] = 'n THEN June ELSE July,
'f => February,
'm => IF Char[5] = 'r THEN March ELSE May,
'a => IF Char[4] = 'p THEN April ELSE August,
's => September,
'o => October,
'n => November,
'd => December,
ENDCASE => ERROR BadTime;
IF t.Length[] < 19
THEN {
temp: BasicTime.Unpacked _ BasicTime.Unpack[BasicTime.Now[]];
uT.zone _ temp.zone;
uT.dst _ temp.dst;
}
ELSE {
uT.zone _ 60 * ( SELECT Char[19] FROM
'g => 0,
'e =>  5,
'c => 6,
'm => 7,
'p => 8, 
'+ => Digit[20],
'- => - Digit[20],
ENDCASE => ERROR BadTime) ;
uT.dst _ IF (Char[20] = 'd) THEN yes ELSE no;
};
time _ BasicTime.Pack[uT];
};
Inner[ ! RuntimeError.UNCAUGHT => CONTINUE];
};
BadTime: ERROR = CODE;
STPInfo: PROC [server, file: ROPE, wantedCreatedTime: GMT] RETURNS [version: Version, bytes: INT, created: GMT] = {
h: Handle _ NIL;
Note: STP.NoteFileProcType = {
info: STP.FileInfo = STP.GetFileInfo[h];
created _ FTPTimeToGMT[info.create];
IF NOT timeSearch OR wantedCreatedTime = created
THEN {
version _ FSName.VersionFromRope[info.version];
bytes _ info.size;
matchFound _ TRUE;
continue _ IF timeSearch THEN no ELSE yes;
}
ELSE continue _ yes;
};
matchFound: BOOL _ FALSE;
timeSearch: BOOL = (wantedCreatedTime # BasicTime.nullGMT);
stpCode: STP.ErrorCode _ noSuchFile;
serverList: LIST OF ROPE = FSPseudoServers.TranslateForRead[server];
replicated: BOOL = FSPseudoServers.AvoidRemoteCheck[server];
innerSTPInfo: PROC [eachServer: ROPE] RETURNS [found: BOOL _ TRUE] = {
ENABLE UNWIND => ReturnConnection[eachServer, h];
h _ NIL;
h _ GetConnection[eachServer, file, FALSE];
STP.Enumerate[h, file, Note
! STP.Error => IF code = noSuchFile THEN CONTINUE ];
IF NOT matchFound THEN {
IF timeSearch THEN {
file _ FSName.BangStarFile[file];
STP.Enumerate[h, file, Note];
};
IF NOT matchFound THEN {stpCode _ noSuchFile; found _ FALSE}; 
};
ReturnConnection[eachServer, h];
};
FOR each: LIST OF ROPE _ serverList, each.rest WHILE each # NIL DO
IF innerSTPInfo[each.first
! STP.Error => {
IF each = serverList THEN stpCode _ code;
IF each.rest = NIL THEN EXIT;
IF stpCode = noSuchFile AND replicated THEN EXIT;
LOOP};
] THEN RETURN ELSE IF replicated THEN EXIT;
ENDLOOP;
ReportSTPError[stpCode, server, file, wantedCreatedTime];
};
MyDesiredProperties: TYPE = PACKED ARRAY STP.ValidProperties OF BoolDefaultFalse;
BoolDefaultFalse: TYPE = BOOL _ FALSE;
namesOnly: MyDesiredProperties = [directory: TRUE, nameBody: TRUE, version: TRUE];
nameSizeCreated: MyDesiredProperties = [
directory: TRUE, nameBody: TRUE, version: TRUE, createDate: TRUE, size: TRUE];
all: STP.DesiredProperties = ALL[TRUE]; -- stops sending of Desired-Property properties
ConditionConnection: PROC[h: Handle, nameBody: ROPE, justNames: BOOL] = {
IF NOT Rope.Match["<*", nameBody]
THEN {
STP.SetDirectory[h, " "];
STP.SetDesiredProperties[h, all];
}
ELSE {
STP.SetDirectory[h, NIL];
STP.SetDesiredProperties[h, IF justNames THEN namesOnly ELSE nameSizeCreated];
};
};
BracketServer: PROC[server: ROPE] RETURNS [ROPE] = {
IF Rope.Match["[*", server]
THEN RETURN [server]
ELSE RETURN [ Rope.Cat[ "[", server, "]" ] ];
};
UnbracketServer: PROC[server: ROPE] RETURNS [ROPE] = {
IF Rope.Match["[*", server]
THEN RETURN [ Rope.Flatten[server, 1, Rope.Length[server]-2]]
ELSE RETURN [ server ];
};
ReportSTPError: PUBLIC PROC [stpCode: STP.ErrorCode, server, file: ROPE, time: GMT] = {
gName: ROPE = Rope.Concat[BracketServer[server], file];
e1: ROPE _ "Server for \"";
e2: ROPE _ "\"";
code: FSBackdoor.ErrorCode;
NewError: PROC [group: FS.ErrorGroup, code: ATOM, explanation: ROPE] = {
ERROR FS.Error[[group, code, Rope.Cat[e1, gName, "\"", explanation]]];
};
IF stpCode = noSuchFile THEN {
FSReport.UnknownFile[gName, time];  -- raises FS.Error
};
SELECT stpCode FROM
noRouteToNetwork, noNameLookupResponse => {
code _ serverInaccessible;
e2 _ "\" is inaccessible";
};
connectionClosed => {
code _ wentOffline;
e2 _ "\" connection closed unexpectedly (wentOffline)";
};
connectionRejected => {
code _ connectionRejected;
e2 _ "\" rejected the connection attempt";
};
connectionTimedOut =>  {
code _ connectionTimedOut;
e2 _ "\" timed-out the connection";
};
accessDenied => {
code _ accessDenied;
e2 _ "\" denied file access permission";
};
requestRefused => {
code _ quotaExceeded;
e1 _ "Request refused (possibily no quota for storing) for \"";
};
accessError => {
code _ fileBusy;
e1 _ "\"";
e2 _ "\" is locked on the server";
};
illegalUserName => {
code _ badCredentials;
e1 _ "Credentials rejected when accessing \"";
};
illegalFileName => {
code _ illegalName;
e2 _ "\" says that the file name is illegal";
};
noSuchHost => {
code _ unknownServer;
e1 _ "Couldn't find the server for \"";
};
alreadyAConnection =>
NewError[bug, $alreadyAConnection, " already had a connection"];
noConnection =>
NewError[bug, $noConnection, " gave a noConnection error"];
illegalUserPassword =>
NewError[environment, $illegalUserPassword, " had an illegal user password"];
illegalUserAccount =>
NewError[environment, $illegalUserAccount, " had an illegal user account"];
illegalConnectName =>
NewError[environment, $illegalConnectName, " had an illegal connect name"];
illegalConnectPassword =>
NewError[environment, $illegalConnectPassword, " had an illegal connect password"];
credentailsMissing =>
NewError[environment, $credentailsMissing, " had missing credentails"];
protocolError =>
NewError[bug, $protocolError, " gave a protocol error to STP"];
noSuchFile =>
NewError[bug, $noSuchFile, " reported no such file"];
undefinedError =>
NewError[bug, $undefinedError, " gave STP an undefinedError"];
ENDCASE => ERROR;
FSBackdoor.ProduceError[code, Rope.Cat[e1, gName, e2]];
};
maxSlots: CARDINAL = 9; -- only need enough for all used in last TimeOut seconds
TimeOut: Process.Seconds _ 7; -- keep connection around for this long after use
SlotArray: TYPE = ARRAY [0..maxSlots) OF Slot;
Slot: TYPE = RECORD [
server: ROPE,
h: Handle,
used: BOOL
];
emptySlot: Slot = [NIL, NIL, FALSE];
new, reused, flushed: INT _ 0; -- statistics
slot: REF SlotArray _ NEW[SlotArray _ ALL [emptySlot]];
haveSlotTimer: BOOL _ FALSE;
ForTimeout: CONDITION _ [Process.SecondsToTicks[TimeOut]];
GrapevineCacheArray: TYPE = ARRAY [0..maxGVineCache) OF GrapevineCacheEntry;
GrapevineCacheEntry: TYPE = RECORD[
name: ROPE _ NIL,
connect: GVBasics.Connect
];
maxGVineCache: CARDINAL = 9; -- its quite expensive to find these out
grapevineCachePut: CARDINAL _ 0;  -- next victim
grapevineCache: REF GrapevineCacheArray _ NEW[GrapevineCacheArray];
GetConnection: PROC [server, pattern: ROPE, justNames: BOOL] RETURNS [h: Handle] = {
h _ LookForConnection[server];
IF h = NIL
THEN {
user, password: ROPE;
h _ STP.Create[];
[user, password] _ UserCredentials.Get[];
STP.Login[h, user, password];
[] _ STP.Open[h, GetServerPupName[server]];
}
ELSE {
IF NOT STP.IsOpen[h] THEN {
[] _ STP.Open[h, GetServerPupName[server]];
};
};
ConditionConnection[h, pattern, justNames];
};
GetServerPupName: PUBLIC PROC [server: ROPE] RETURNS [pupServer: ROPE] = {
IF server.Find[".", 0, FALSE] > 0 THEN {
info: GVNames.ConnectInfo;
connect: GVBasics.Connect;
foundInCache: BOOL;
[found: foundInCache, connect: connect] _  FindInGrapevineCache[name: server];
IF foundInCache THEN RETURN[connect];
[info: info, connect: connect ] _ GVNames.GetConnect[server];
IF info = group OR info = individual THEN {
AddToGrapevineCache[name: server, connect: connect];
RETURN[connect];
};
};
RETURN[server];
};
FindInGrapevineCache: ENTRY PROC [name: ROPE] RETURNS [found: BOOL _ FALSE, connect: GVBasics.Connect] = {
FOR i: CARDINAL IN [0..maxGVineCache) DO
IF Rope.Equal[name, grapevineCache[i].name, FALSE] THEN RETURN[TRUE, grapevineCache[i].connect];
ENDLOOP;
};
AddToGrapevineCache: ENTRY PROC [name: ROPE, connect: GVBasics.Connect] = {
grapevineCache[grapevineCachePut].name _ name;
grapevineCache[grapevineCachePut].connect _ connect;
IF (grapevineCachePut _ grapevineCachePut + 1) >= maxGVineCache THEN grapevineCachePut _ 0;
};
LookForConnection: ENTRY PROC[server: ROPE] RETURNS [h: Handle] = {
ENABLE UNWIND => NULL;
FOR i: CARDINAL IN [0..maxSlots) DO
IF slot[i] # emptySlot AND Rope.Equal[slot[i].server, server, FALSE] THEN  {
reused _ reused + 1;
h _ slot[i].h;
slot[i] _ emptySlot;
RETURN;
};
ENDLOOP;
h _ NIL;
new _ new + 1;
};
ReturnConnection: PROC [server: ROPE, h: Handle] = {
IF server = NIL OR h = NIL THEN RETURN;
IF STP.IsOpen[h] AND NOT SaveConnection[server, h] THEN
STP.Close[h ! STP.Error => CONTINUE ];
};
SaveConnection: ENTRY PROC [server: ROPE, h: Handle] RETURNS [BOOL] = {
ENABLE UNWIND => NULL;
FOR i: CARDINAL IN [0..maxSlots) DO
IF slot[i] = emptySlot THEN {
slot[i] _ [server, h, TRUE];
IF NOT haveSlotTimer THEN TRUSTED {
haveSlotTimer _ TRUE;
Process.Detach[FORK SlotTimer[]];
};
RETURN [TRUE];
};
ENDLOOP;
RETURN [FALSE];
};
SlotTimer: PROC = {
i: CARDINAL _ 0;
h: Handle;
DO
[h, i] _ NextInterestingSlot[i];
IF h = NIL THEN RETURN;
STP.Close[h ! STP.Error => LOOP ];
flushed _ flushed + 1;
ENDLOOP;
};
NextInterestingSlot: ENTRY PROC [start: CARDINAL] RETURNS [h: Handle, index: CARDINAL]  = {
ENABLE UNWIND => NULL;
DO
IF start = 0 THEN WAIT ForTimeout;
FOR index IN [start..maxSlots) DO
IF slot[index] # emptySlot THEN {
IF slot[index].used
THEN slot[index].used _ FALSE
ELSE { -- here's one that needs to be closed
h _ slot[index].h;
slot[index] _ emptySlot;
RETURN;
};
};
ENDLOOP;
FOR index IN [0 .. maxSlots) DO
IF slot[index] # emptySlot THEN EXIT; -- need to stick around
REPEAT FINISHED => { -- nothing more to do
h _ NIL;
index _ maxSlots;
haveSlotTimer _ FALSE;
RETURN;
};
ENDLOOP;
start _ 0;
ENDLOOP;
};
}.
���ô��FSRemoteFileImpl.mesa
Copyright c 1984, 1985, 1986 by Xerox Corporation.  All rights reserved.
HGM, February 8, 1984 11:55:19 pm PST
Bob Hagmann, August 2, 1985 4:38:26 pm PDT
Doug Wyatt, November 27, 1984 3:53:09 pm PST -- added allDown test to Info
Russ Atkinson (RRA) April 8, 1986 12:59:54 pm PST
Tim Diebert: February 11, 1986 9:39:22 am PST
Exported to FSRemoteFile
[file: ROPE] RETURNS [answer: {do, skip, abort}, localStream: STREAM]
[file: ROPE] RETURNS [continue: BOOL]
[file: ROPE] RETURNS [continue: BOOL]
This helpful procedure allows enumeration for either names or information.
RRA: this allows us to abort during an enumeration, which is non-trivial
RRA: certain STP servers, like Nebula, do not prepend "<>" if they do not support directories.  Since FS demands this syntax, we should make sure that it is here.
If we do not get a match then we yield nothing.  If replicated, then there is also no reason to try other servers, since replication should not affect presence.  Otherwise, we go on to the next server, provided that we have not yielded something from this server.
If we have seen at least one file then we do NOT try other servers, which would royally screw up the enumeration.
If the auxilliary servers do not work, we report the error from the first server only.  So we remember the error code here.
Any other errors during auxiliiary severs searches just go on to try the next server in the list (if any).
If we continue here, we have enumerated the pattern all right, and have returned the connection.
If we continue here, we have an error of some kind during the enumeration, so we report it.
No such file was the response.  This is a positive response that the named file was not present on the named server.
If we are NOT assuming replicated files, then we go look for another server.
If we wanted any date, and we are assuming replicated files, then we should just give up right now, since we will not find a match.
If we wanted a specific date, then we may just have a bad version number hint, so we exit to do the search the expensive way.
We got a response that the file was present.
We were requested to find any date, so the one we got was OK.
We were asked for a specific date, and we got it, so its all OK.
We were asked for a specific date, and the file was there, but the date was wrong, which means that the version # hint was bogus.  If we assume the files are replicated, we should exit, since the version hint is wrong on the replicated servers as well.  Otherwise, we loop, hoping that another server will have the correct hint and date as well.
The line of code following fails if there is no response to a single packet info check.  Tim D.
IF allDown THEN ReportError[noNameLookupResponse];
This call is for the general case.  It is more expensive, of course, since we have to grab a connection for it.  However, STPInfo can handle bogus version # hints.
[file: ROPE] RETURNS [answer: {do, skip, abort}, localStream: STREAM] 
[file: ROPE] RETURNS [continue: BOOL]
In this case we have a single-character day of month with no leading blank.  We accept this number, as well as adjusting the indexing. 
Yetch, FTPServer on AltoGateway does this. Use local zone info.
Internal procedures
[file: ROPE] RETURNS [continue: BOOL]
If version part was missing from client's file name, then Enumerate will produce all versions, but we only want the !H version
Property stuff
no directory, so turn off directory defaulting and Desired-Property properties
Internal procedures
STP connection cacheing
need a new connection
already had a connection
Names with "." are GVNames (Grapevine names), so ask Grapevine to look them up
If successful, use the connect as the server name for STP.Open
Bob Hagmann April 29, 1985 9:12:49 am PDT
changes to: DIRECTORY, GetConnection
Bob Hagmann April 29, 1985 10:03:03 am PDT
changes to: DIRECTORY, GetConnection, GetServerPupName, LookForConnection, FSRemoteFileImpl

Bob Hagmann May 6, 1985 4:13:27 pm PDT
changes to: InnerEnumerate
Bob Hagmann August 2, 1985 3:25:38 pm PDT
changes to: maxSlots, TimeOut, GetServerPupName, FindInGrapevineCache, AddToGrapevineCache, LookForConnection, ForTimeout, GrapevineCacheEntry, maxGVineCache, grapevineCachePut, grapevineCache, GetConnection

Bob Hagmann August 2, 1985 4:37:37 pm PDT
changes to: grapevineCachePut

Êä��–

"cedar" style˜�
code2š
œ™Jšœ
Ïm
œ=™HIcode1™%L™*L™JIcode™1M™-—š
Ïk	˜	Lšœ
žœžœžœ!˜<Lšžœ
žœ)˜1Lšœžœ$˜4Lšœžœ2˜>LšœžœK˜`Lšœ
žœ%˜7Lšœ	žœ˜Lšœ	žœ˜Lšœžœ˜(Lšžœ
žœžœ˜Lšœžœ2˜?Lšœžœ;žœ˜KLšœ
žœžœ
ž
˜Lšžœ
žœø
˜Lšœžœ˜—šœžœ
ž˜Lšžœžœežœ˜Ž
Lšžœ
˜Lš
œ˜L˜�Lšžœžœ
žœ
˜Lšœžœžœ˜Lšžœžœžœ
˜Lšœžœ$˜:Lšžœžœžœ
žœ
˜Lšœ	žœ˜#L˜�—š
œ™š
Ïnœžœ
žœžœžœ%˜dšœ	žœ˜ Kšœžœžœ*žœ
™EKšœžœžœ˜(Kšœ	žœ˜)šžœ
žœ
ž˜Kš
œ˜šžœžœ!˜2Kšœ	žœ-žœžœ˜KKšœ
žœ
˜Kš
œ˜—Kšžœ˜—Kš
œ˜—Kšœžœžœ
˜Kšœžœ+˜>Kšœ	žœ˜$Kšœžœ
˜š	œ
žœ
žœžœžœ˜/Kšœ	žœ>˜KKšœžœ
˜˜
Kšžœ
žœ!˜.Kšœ!žœ˜(šžœ˜Kš	œžœ
žœžœ
žœ˜4—šžœ
žœžœ˜šžœžœ˜Kš
œ!˜!Kšžœ˜Kš
œ˜—Kš
žœ
žœžœžœžœ˜>Kš
œ˜—K˜—Kš
œ˜Kš
œ˜—Kš
žœžœžœžœ
žœ
˜GKš
œ9˜9Kš
œ˜—šŸœžœ
žœžœ˜Lš
œ˜Kšœžœžœžœ
™%Kšœžœžœ˜(Kšœžœ˜3šœžœ"žœ˜JKšžœžœ˜—Kš
œ˜—Kšœ	žœ˜&Kšœ*žœ˜1Kš
œ˜—šŸœžœ
žœžœ˜Mš
œ˜Kšœžœžœžœ
™%Kšœžœ"žœžœ˜@Kš
œ˜—Kšœ	žœ˜&Kšœ*žœ˜0Kšœ
ž
˜—KšŸ
œžœžœžœžœžœ˜Tš
Ÿœžœ
žœžœ"žœ˜]Kš
œJ™JKšœ	žœ˜$Kšœžœ
˜Kšœ
žœžœ
˜šœžœ˜#š
œ˜Kš
œH™H—Kšœžœ
˜šžœ
žœžœ ˜BKš
Ϣ
™¢
—Kš
œ˜K˜—šœžœžœ˜%Kšœžœ
˜˜
Kšžœ
žœ"˜/Kš
œ0˜0Kšžœ"˜%K˜—Kš
œ˜K˜—Kšœžœ
žœ
žœ,˜DKšœžœ,˜<š
žœžœ
žœ
žœžœžœ
ž˜Bš
œ˜šœžœ	˜šžœ
žœ
ž˜š
œ˜Kš
œ‡™‡šžœ
žœ
ž˜Kšœžœ
žœ
˜'Kšžœžœ
˜——š
œ
˜
Kš
œq™qKšœžœ˜—š
œ˜Kš
œ{™{Kšœžœ˜—šžœ˜
Kš
œj™jKšžœ
˜———Kš
œ˜—Kš
œ`™`Kšžœ
˜Kšžœ
˜—Kš
œ[™[Kšžœžœ=˜YKšžœ˜Kš
œ˜—šŸœžœ
žœžœžœ
žœžœžœ˜wšŸœžœžœ˜.Kš
œ9˜9Kš
œ˜—Kš
œ"˜"Kšœžœ
žœ
žœ,˜DKšœžœ,˜<Kšœ	žœžœ
˜š
žœžœ
žœ
žœžœžœ
ž˜BKšœžœ˜Kšœžœžœ
˜Kš
œJ˜JKšžœžœžœ
˜*šžœž˜š
œ˜Kš
œt™tšžœ
žœžœ
žœ
˜Kš
œL™L—šžœ'žœ˜FKš
œƒ
™ƒ
—šžœ
˜K™}—K˜—š
œ˜Kš
œ,™,šžœ'žœ
žœ
˜5Kš
œ=™=—šžœžœ
žœ
˜+Kš
Ïc@™@—šžœ
žœžœ
žœ
˜Kš
œÙ™Ù—Kšžœ˜—Kšžœ
˜—Kšžœ
˜—K™_Kšžœ	žœ#™2Kš
ϣ
™£
Kš
œE˜EKš
œ˜—šŸœžœ
žœžœžœ
žœ%˜pKšœ	žœ˜$Kš
œ?˜?š	œ
žœ
žœžœžœ˜/Kšœžœ
˜Kšœ	žœ-˜:˜
Kšžœ
žœ!˜.Kšœ%žœ˜+Kš
œ5˜5Kšžœ˜ K˜—Kš
œ˜Kš
œ˜—šžœžœ˜Kš
žœžœžœžœ
žœ
˜FKš
œ;˜;K˜—Kš
œ˜—šŸœžœ
žœžœžœžœžœ	žœžœžœžœ˜Ž
Kšœžœžœ
˜Kšœžœ+˜;Kšœžœ
˜Kšœ	žœ˜$Kšœ	žœ˜&šœ	žœ˜ Kšœžœžœ*žœ™FKšœžœžœ˜(Kšœ	žœ˜)šžœ
žœ
ž˜Kš
œ˜šžœžœ!˜2Kš
œC˜CKš	œ	žœžœ
žœžœ˜1Kšœ
žœ
˜Kš
œ˜—Kšžœ˜—Kš
œ˜—šœžœžœžœžœžœ˜IKšœžœ
˜˜
Kšžœ
žœ$˜1Kšœ$žœ˜+šžœ˜Kš	œžœ
žœžœ
žœ˜4—šžœ
žœžœ˜šžœžœ˜Kš
œ!˜!Kšžœ˜Kš
œ˜—Kšžœ
žœžœ"žœ˜?Kš
œ˜—K˜—Kš
œ ˜ K˜—Kšœžœ
žœ
žœ,˜DKšœžœ,˜<š
žœžœ
žœ
žœžœžœ
ž˜Bšžœ˜šœžœ˜Kšžœžœ˜)Kšžœ
žœ
žœ
žœ
˜Kšžœžœžœ
žœ
˜1Kšžœ
˜—Kš
œžœ
žœ
žœ
žœžœ
žœ
˜+—Kšžœ
˜—Kš
œ9˜9Kš
œ˜—šŸœžœ
žœžœžœžœ%˜fKšœžœ
˜šœžœ˜Kšœžœžœžœ
™%Kšœžœ"žœ˜KKšœžœžœžœ˜$Kš
œ˜—š	œžœ
žœžœžœ˜.Kšœ	žœ-˜:˜
Kšžœ
žœ!˜.Kšœ!žœ˜'Kšžœ-˜0K˜—Kš
œ˜Kš
œ˜—Kšœ	žœ˜$Kš
žœžœžœžœ
žœ
˜FKš
œ9˜9Kš
œ˜—šŸœžœ
žœ
žœžœžœ˜^Kšœžœ˜š
Ÿœžœ	žœžœžœ˜/Kšœžœ˜&šžœž˜
Kšœžœ˜Kšžœ
žœ˜Kšžœžœ	˜—K˜—š
Ÿœžœ	žœžœžœ˜5Kšžœ$˜*K˜—š
Ÿœžœ	žœžœžœ˜*Kšœžœ˜šžœž˜
Kšœžœžœ
žœ˜3Kšžœ
žœ˜$Kšžœžœ	˜—Kš
œ˜—šŸœžœ˜Kš
œ˜Kšœžœ˜šžœž˜Kš
œ˜Kšžœ˜—šžœ	žœ	˜Kšžœ˜šžœ˜Kš
œ‡
™‡
Kš
œ˜Kš
œ˜——Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜šœžœ	ž˜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šœ	žœžœ
˜—™šŸœžœžœžœ
žœžœžœ˜sKšœžœ
˜šœžœ˜Kšœžœžœžœ
™%Kšœžœžœ˜(Kš
œ$˜$šžœ
žœžœ˜0šžœ˜Kš
œ/˜/Kš
œ˜Kšœ
žœ
˜K™~Kšœžœžœžœ˜*Kš
œ
˜
—Kšžœ˜—Kš
œ˜—Kšœžœžœ
˜Kšœžœ+˜;Kšœ	žœ˜$Kšœžœ
žœ
žœ,˜DKšœžœ,˜<šœžœžœžœ	žœžœ˜FKšžœ
žœ$˜1Kšœžœ
˜Kšœ$žœ˜+šžœ˜Kš	œžœ
žœžœ
žœ˜4—šžœ
žœžœ˜šžœžœ˜Kš
œ!˜!Kšžœ˜Kš
œ˜—Kšžœ
žœžœ žœ˜>Kš
œ˜—Kš
œ ˜ K˜—š
žœžœ
žœ
žœžœžœ
ž˜Bšžœ˜šœžœ˜Kšžœžœ˜)Kšžœ
žœ
žœ
žœ
˜Kšžœžœžœ
žœ
˜1Kšžœ˜—Kš
œžœ
žœ
žœ
žœžœ
žœ
˜+—Kšžœ
˜—Kš
œ9˜9Kš
œ˜——™Kšœžœžœ
žœ
žœžœ˜QKšœžœžœžœ
˜&Kšœ-žœžœžœ˜Rš
œ(˜(Kšœžœžœžœžœžœ˜N—Kšœžœžœ
žœ /˜WšŸœžœžœ
žœ˜Išžœ
žœ˜!šžœ˜Kš
œN™NKšžœ˜Kšžœ˜!Kš
œ
˜
—šžœ˜Kšžœžœ˜Kšžœžœžœžœ˜NKš
œ˜——Kš
œ˜——™š
Ÿ
œžœ	žœžœžœ˜4šžœ˜Kšžœ
žœ	˜Kšžœ
žœ"˜-—Kš
œ˜—š
Ÿœžœ	žœžœžœ˜6šžœ˜Kšžœ
žœ2˜=Kšžœ
žœ˜—Kš
œ˜—šŸœžœ
žœžœžœžœ˜WKšœžœ,˜7Kšœžœ˜Kšœžœ˜Kš
œ˜š
Ÿœžœ	žœžœžœ˜HKšžœ
žœ>˜FK˜—šžœžœ˜Kšœ$ ˜6Kš
œ˜—šžœ	ž˜š
œ+˜+Kš
œ˜Kš
œ˜Kš
œ˜—š
œ˜Kš
œ˜Kš
œ7˜7Kš
œ˜—š
œ˜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˜M—š
œ˜Kš
œK˜K—š
œ˜Kš
œK˜K—š
œ˜Kš
œS˜S—š
œ˜Kš
œG˜G—š
œ˜Kš
œ?˜?—š
œ
˜
Kš
œ5˜5—š
œ˜Kš
œ>˜>—Kšžœžœ
˜—Kš
œ7˜7Kš
œ˜——™Kšœ
žœ 8˜PKšœ 1˜OKšœžœžœžœ˜.šœžœžœ˜Kšœžœ
˜
Kš
œ
˜
Kšœž˜
Kš
œ˜—Kšœžœžœžœ˜$Kšœžœ 
˜,Kšœžœ
žœ
žœ˜7Kšœžœžœ
˜Kšœž	œ%˜:Kšœžœžœžœ˜Lšœžœžœ
˜#Kšœžœžœ
˜Kš
œ˜K˜—Kšœžœ (˜EKšœžœ ˜0Kšœžœžœ˜Cš
Ÿ
œžœžœ
žœžœ˜TKš
œ˜šžœž˜
šžœ˜Kš
œ™Kšœžœ
˜Kšœžœ
˜Kš
œ)˜)Kšžœ˜Kšœžœ#˜+Kš
œ
˜
—šžœ˜Kš
œ™šžœ
žœ
žœž˜Kš
œ+˜+K˜—Kš
œ˜——Kš
œ+˜+Kš
œ˜—š
Ðbnœžœ
žœžœ
žœ˜Jšžœžœžœ˜(K™NKš
œ˜Kš
œ˜Kšœžœ
˜Kš
œN˜NKšžœžœ
žœ
˜%š
œ=˜=Kšœ6žœ™>—šžœžœžœ˜+Kš
œ4˜4Kšžœ
˜K˜—K˜—Kšžœ	˜K˜—šŸœžœ
žœžœžœ	žœžœ ˜jšžœžœ
žœž˜(Kš
žœ*žœžœ
žœ
žœ˜`Kšžœ
˜—K˜—šŸœžœ
žœžœ ˜KKš
œ.˜.Kš
œ4˜4Kšžœ>žœ˜[K˜—š
Ÿœžœ
žœ	žœžœ˜CKšžœ
žœžœ
˜šžœžœ
žœž˜#šžœžœ$žœ
žœ˜LKš
œ˜Kš
œ˜Kš
œ˜Kšžœ
˜Kš
œ˜—Kšžœ
˜—Kšœžœ
˜Kš
œ˜Kš
œ˜—šŸœžœ
žœ˜4Kšžœ
žœ
žœžœ
žœ
žœ
˜'š	žœ
žœžœ
žœž˜7Kšžœžœ
žœ˜&—Kš
œ˜—šŸœžœ
žœ
žœ
žœžœ˜GKšžœ
žœžœ
˜šžœžœ
žœž˜#šžœžœ
˜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šœÏr™$—™*Mšœ¢O™[—M™�™&Mšœ¢™—™)Mšœ¢Ã
™Ï
—M™�™)Mšœ¢™—M™�—�…—����Jè��xÀ��