<> <> <> <> <> <> <> <> <> DIRECTORY BasicTime USING [GMT, Now, nullGMT, Pack, Unpack, Unpacked], FS USING [Error, ErrorGroup, FileType, tUnspecified], FSBackdoor USING [ErrorCode, ProduceError, Version], FSName USING [BangStarFile, BangVersionFile, VersionFromRope], FSRemoteFile USING [], FSRemoteFileBackdoor USING [CloseProc, DeleteProc, DoProc, EnumerateForInfoProc, EnumerateForNamesProc, ErrorNotImplemented, GetInfoProc, GetServerProc, OpenProc, Register, RenameProc, RetrieveProc, RWProc, ServerHandle, ServerObject, ServerProcs, ServerProcsObject, StoreProc, SweepProc, ValidateProc], FSReport USING [UnknownFile], GVBasics USING [Connect], GVNames USING [ConnectInfo, GetConnect], IO USING [STREAM], Process USING [CheckForAbort, Detach, EnableAborts], Rope USING [Cat, Concat, Equal, Fetch, Find, FindBackward, Length, Match, ROPE], RuntimeError USING [UNCAUGHT], SafeStorage USING [EnableFinalization, EstablishFinalization, FinalizationQueue, FQEmpty, FQNext, NewFQ], STP USING [Close, ConfirmProcType, Continue, Create, Delete, DesiredProperties, Enumerate, Error, ErrorCode, FileInfo, GetFileInfo, Handle, IsOpen, Login, NoteFileProcType, Open, Rename, Retrieve, SetDesiredProperties, SetDirectory, Store, ValidProperties], STPFSRemoteFile USING [Lookup, LookupResult, ServerData, ServerDataObject], UserCredentials USING [Get]; STPFSRemoteFileImpl: CEDAR MONITOR IMPORTS BasicTime, FS, FSBackdoor, FSName, FSRemoteFileBackdoor, FSReport, GVNames, Process, Rope, RuntimeError, SafeStorage, STP, STPFSRemoteFile, UserCredentials EXPORTS FSRemoteFile -- ought to be removed --, STPFSRemoteFile ~ { <> GMT: TYPE = BasicTime.GMT; ROPE: TYPE = Rope.ROPE; ServerData: TYPE ~ STPFSRemoteFile.ServerData; ServerHandle: TYPE ~ FSRemoteFileBackdoor.ServerHandle; ServerObject: TYPE ~ FSRemoteFileBackdoor.ServerObject; STREAM: TYPE = IO.STREAM; Version: TYPE = FSBackdoor.Version; <> myFlavor: ATOM _ $STP; myServerProcs: FSRemoteFileBackdoor.ServerProcs _ NEW[FSRemoteFileBackdoor.ServerProcsObject _ [STPSweep, STPValidate, STPDelete, STPDo, STPEnumerateForInfo, STPEnumerateForNames, STPGetInfo, STPRename, STPRetrieve, STPStore, STPOpen, STPClose, STPReadWrite]]; initialConnectionTTL: CARD _ 8; upServerTTL: CARD _ 0; -- irrelevant downServerTTL: CARD _ 30; busyServerTTL: CARD _ 10; credentialsErrorTTL: CARD _ 30; maxGrapevineCache: CARDINAL = 7; <> STPDelete: FSRemoteFileBackdoor.DeleteProc -- [h: ServerHandle, file: ROPE, wantedCreatedTime: GMT, case: BOOL, proc: ConfirmProc] -- ~ { matchFound: BOOLEAN _ FALSE; timeSearch: BOOLEAN = (wantedCreatedTime # BasicTime.nullGMT); stpCode: STP.ErrorCode _ noSuchFile; stpH: STP.Handle; Confirm: STP.ConfirmProcType -- [file: ROPE] RETURNS [answer: {do, skip, abort}, localStream: STREAM] -- ~ { info: STP.FileInfo = STP.GetFileInfo[stpH]; created: GMT = FTPTimeToGMT[info.create]; SELECT TRUE FROM matchFound => answer _ abort; (NOT timeSearch) OR (wantedCreatedTime = created) => { answer _ IF (proc = NIL) OR (proc [FSName.VersionFromRope[info.version]]) THEN do ELSE abort; matchFound _ TRUE; }; ENDCASE => answer _ skip; }; InnerDelete: PROC RETURNS [ok: BOOL _ TRUE] ~ { stpH _ NIL; { ENABLE UNWIND => IF stpH # NIL THEN ReturnConnection[h, stpH]; stpH _ GetConnection[h, file, FALSE]; STP.Delete[stpH, file, Confirm ! STP.Error => IF code = noSuchFile THEN CONTINUE ]; IF NOT matchFound THEN { IF timeSearch THEN { file _ FSName.BangStarFile[file]; STP.Delete[stpH, file, Confirm]; }; IF NOT matchFound THEN { ReturnConnection[h, stpH]; stpCode _ noSuchFile; RETURN [FALSE]}; }; }; ReturnConnection[h, stpH]; }; CheckUnimplemented[h, file, case]; IF InnerDelete[ ! STP.Error => {stpCode _ code; CONTINUE}] THEN RETURN; ReportSTPError[stpCode, h, file, wantedCreatedTime]; }; STPDo: FSRemoteFileBackdoor.DoProc -- [h: ServerHandle, cmd: ATOM, arg: REF, result: REF] -- ~ { FSRemoteFileBackdoor.ErrorNotImplemented[h, NIL, "STPDo"]; }; STPEnumerateForInfo: FSRemoteFileBackdoor.EnumerateForInfoProc -- [h: ServerHandle, pattern: ROPE, case: BOOL, proc: InfoProc] -- ~ { NoteInfo: LocalEnumProc -- [stpH: STP.Handle, file: ROPE] RETURNS [continue: BOOL] -- ~ { info: STP.FileInfo ~ STP.GetFileInfo[stpH]; created: BasicTime.GMT ~ FTPTimeToGMT[info.create]; continue _ (proc = NIL) OR (proc[file, info.size, created, FS.tUnspecified]); }; CheckUnimplemented[h, pattern, case]; InnerEnumerate[h, pattern, NoteInfo, FALSE]; }; STPEnumerateForNames: FSRemoteFileBackdoor.EnumerateForNamesProc -- [h: ServerHandle, pattern: ROPE, case: BOOL, proc: NameProc] -- ~ { NoteName: LocalEnumProc -- [stpH: STP.Handle, file: ROPE] RETURNS [continue: BOOL] -- ~ { RETURN[ (proc = NIL) OR (proc[file]) ] }; CheckUnimplemented[h, pattern, case]; InnerEnumerate[h, pattern, NoteName, TRUE]; }; LocalEnumProc: TYPE = PROC [stpH: STP.Handle, file: ROPE] RETURNS [continue: BOOL]; InnerEnumerate: PROC [h: ServerHandle, pattern: ROPE, note: LocalEnumProc, namesOnly: BOOL] ~ { <> stpH: STP.Handle; InnerNote: STP.NoteFileProcType ~ { Process.CheckForAbort[]; <> IF NOT Rope.Match["<*", file] THEN file _ Rope.Concat["<>", file]; <" if they do not support directories. Since FS demands this syntax, we should make sure that it is here.>> continue _ IF note[stpH, file] THEN yes ELSE no; }; InnerBlock: PROC ~ { stpH _ NIL; { ENABLE UNWIND => IF stpH # NIL THEN ReturnConnection[h, stpH]; stpH _ GetConnection[h, pattern, namesOnly]; STP.Enumerate[stpH, pattern, InnerNote]; }; ReturnConnection[h, stpH]; }; InnerBlock[ ! STP.Error => ReportSTPError[code, h, pattern, BasicTime.nullGMT] ]; }; STPGetInfo: FSRemoteFileBackdoor.GetInfoProc -- [h: ServerHandle, file: ROPE, wantedCreatedTime: GMT, case: BOOL] RETURNS [version: Version, bytes: INT, created: GMT, fileType: FS.FileType] -- ~ { result: STPFSRemoteFile.LookupResult; CheckUnimplemented[h, file, case]; fileType _ FS.tUnspecified; [result, version, created, bytes] _ STPFSRemoteFile.Lookup[h, file]; SELECT result FROM ok => { <> IF wantedCreatedTime = BasicTime.nullGMT THEN RETURN; <> IF wantedCreatedTime = created THEN RETURN; <> }; noSuchFile => { <> IF wantedCreatedTime = BasicTime.nullGMT THEN ReportSTPError[noSuchFile, h, file, wantedCreatedTime]; }; ENDCASE => NULL; <> [version, bytes, created] _ STPInfoIgnoringVersionHint[h, file, wantedCreatedTime]; }; STPInfoIgnoringVersionHint: PROC [h: ServerHandle, file: ROPE, wantedCreatedTime: GMT] RETURNS [version: Version, bytes: INT, created: GMT] = { stpH: STP.Handle _ NIL; Note: STP.NoteFileProcType -- [file: ROPE] RETURNS [continue: Continue] -- ~ { info: STP.FileInfo = STP.GetFileInfo[stpH]; 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; InnerSTPInfo: PROC RETURNS [found: BOOL _ TRUE] ~ { ENABLE UNWIND => IF stpH # NIL THEN ReturnConnection[h, stpH]; stpH _ NIL; stpH _ GetConnection[h, file, FALSE]; STP.Enumerate[stpH, file, Note ! STP.Error => IF code = noSuchFile THEN CONTINUE ]; IF NOT matchFound THEN { IF timeSearch THEN { file _ FSName.BangStarFile[file]; STP.Enumerate[stpH, file, Note]; }; IF NOT matchFound THEN {stpCode _ noSuchFile; found _ FALSE}; }; ReturnConnection[h, stpH]; }; IF InnerSTPInfo[ ! STP.Error => { stpCode _ code; CONTINUE }] THEN RETURN; ReportSTPError[stpCode, h, file, wantedCreatedTime]; }; STPRename: FSRemoteFileBackdoor.RenameProc -- [h: ServerHandle, fromFile: ROPE, fromCreated: GMT, toFile: ROPE, case: BOOL, proc: ConfirmProc] -- ~ { stpCode: STP.ErrorCode _ noSuchFile; version: Version; InnerRename: PROC RETURNS [ok: BOOL _ TRUE] ~ { stpH: STP.Handle _ NIL; { ENABLE UNWIND => IF stpH # NIL THEN ReturnConnection[h, stpH]; stpH _ GetConnection[h, fromFile, TRUE]; fromFile _ FSName.BangVersionFile[fromFile, version]; STP.Rename[stpH, fromFile, toFile]; }; ReturnConnection[h, stpH]; }; CheckUnimplemented[h, fromFile, case]; CheckUnimplemented[h, toFile, case]; version _ STPGetInfo[h, fromFile, fromCreated, case].version; IF (proc = NIL) OR (proc[version]) THEN { IF InnerRename[! STP.Error => {stpCode _ code; CONTINUE}] THEN RETURN; ReportSTPError[stpCode, h, toFile, BasicTime.nullGMT]; }; }; STPRetrieve: FSRemoteFileBackdoor.RetrieveProc -- [h: ServerHandle, file: ROPE, wantedCreatedTime: GMT, case: BOOL, proc: ConfirmRetrieveProc] -- ~ { matchFound: BOOL _ FALSE; timeSearch: BOOL = (wantedCreatedTime # BasicTime.nullGMT); stpH: STP.Handle _ NIL; stpCode: STP.ErrorCode _ noSuchFile; Confirm: STP.ConfirmProcType ~ { <<[file: ROPE] RETURNS [answer: {do, skip, abort}, localStream: STREAM] >> info: STP.FileInfo = STP.GetFileInfo[stpH]; created: GMT = FTPTimeToGMT[info.create]; SELECT TRUE FROM matchFound => answer _ abort; (NOT timeSearch) OR (wantedCreatedTime = created) => { localStream _ proc[file, info.size, created, FS.tUnspecified]; answer _ IF localStream = NIL THEN abort ELSE do; matchFound _ TRUE; }; ENDCASE => answer _ skip; }; InnerRetrieve: PROC RETURNS [success: BOOL _ TRUE] ~ { stpH _ NIL; { ENABLE UNWIND => IF stpH # NIL THEN ReturnConnection[h, stpH]; stpH _ GetConnection[h, file, FALSE]; STP.Retrieve[stpH, file, Confirm ! STP.Error => IF code = noSuchFile THEN CONTINUE ]; IF NOT matchFound THEN { IF timeSearch THEN { file _ FSName.BangStarFile[file]; STP.Retrieve[stpH, file, Confirm]; }; IF NOT matchFound THEN {stpCode _ noSuchFile; success _ FALSE}; }; }; ReturnConnection[h, stpH]; }; CheckUnimplemented[h, file, case]; IF InnerRetrieve[ ! STP.Error => { stpCode _ code; CONTINUE }] THEN RETURN; ReportSTPError[stpCode, h, file, wantedCreatedTime]; }; STPStore: FSRemoteFileBackdoor.StoreProc -- [h: ServerHandle, file: ROPE, case: BOOL, str: STREAM, created: GMT, proc: ConfirmProc] -- ~ { stpH: STP.Handle _ NIL; stpCode: STP.ErrorCode; Note: STP.NoteFileProcType -- [file: ROPE] RETURNS [continue: Continue] -- ~ { IF proc = NIL THEN RETURN [yes]; RETURN[ IF proc[FSName.VersionFromRope[STP.GetFileInfo[stpH].version]] THEN yes ELSE no ]; }; InnerStore: PROC RETURNS [ok: BOOL _ TRUE] ~ { stpH _ NIL; { ENABLE UNWIND => IF stpH # NIL THEN ReturnConnection[h, stpH]; stpH _ GetConnection[h, file, TRUE]; STP.Store[stpH, file, str, Note, unknown, created]; }; ReturnConnection[h, stpH]; }; CheckUnimplemented[h, file, case]; stpCode _ noSuchFile; IF InnerStore[ ! STP.Error => {stpCode _ code; CONTINUE}] THEN RETURN; ReportSTPError[stpCode, h, file, BasicTime.nullGMT]; }; STPOpen: FSRemoteFileBackdoor.OpenProc -- [h: ServerHandle, cmd: ATOM, file: ROPE, wantedCreatedTime: GMT, case: BOOL, proc: ConfirmRetrieveProc] RETURNS [FileHandle] -- ~ { FSRemoteFileBackdoor.ErrorNotImplemented[h, NIL, "STPOpen"]; RETURN[NIL]; }; STPClose: FSRemoteFileBackdoor.CloseProc -- [h: ServerHandle, fileHandle: FileHandle] -- ~ { FSRemoteFileBackdoor.ErrorNotImplemented[h, NIL, "STPClose"]; }; STPReadWrite: FSRemoteFileBackdoor.RWProc -- [h: ServerHandle, fileHandle: FileHandle, cmd: ATOM, bytePos: CARD, block: REF TEXT] RETURNS [bytesTransferred: CARD] -- ~ { FSRemoteFileBackdoor.ErrorNotImplemented[h, NIL, "STPReadWrite"]; }; <> 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; <> STPGetServer: FSRemoteFileBackdoor.GetServerProc -- [server: ROPE] RETURNS [h: ServerHandle, downMsg: ROPE _ NIL] -- ~ { <> <> serverPupName: ROPE; data: STPFSRemoteFile.ServerData; stpH: STP.Handle; stpErrorCode: STP.ErrorCode; opened: BOOL _ FALSE; IF (serverPupName _ GetServerPupName[server]) = NIL THEN RETURN [NIL, NIL]; { ENABLE STP.Error => { stpErrorCode _ code; CONTINUE }; user, password: ROPE; stpH _ STP.Create[]; [user, password] _ UserCredentials.Get[]; STP.Login[stpH, user, password]; [] _ STP.Open[stpH, serverPupName]; opened _ TRUE; }; IF NOT opened THEN SELECT stpErrorCode FROM noSuchHost, noNameLookupResponse => RETURN [NIL, NIL]; ENDCASE => RETURN[NIL, "can't connect"]; data _ NEW[STPFSRemoteFile.ServerDataObject _ [ttl~upServerTTL, downMsg~NIL, connectionTTL~initialConnectionTTL, stpH~stpH, serverPupName~serverPupName]]; SafeStorage.EnableFinalization[data]; h _ NEW[ServerObject _ [flavor~myFlavor, name~server, procs~myServerProcs, data~data]]; RETURN [h, NIL]; }; GetConnection: PROC [h: ServerHandle, pattern: ROPE, justNames: BOOL] RETURNS [stpH: STP.Handle] ~ { data: ServerData ~ NARROW[h.data]; GetConnectionInner: ENTRY PROC ~ --INLINE-- { stpH _ data.stpH; data.stpH _ NIL; }; GetConnectionInner[]; IF stpH = NIL THEN { user, password: ROPE; stpH _ STP.Create[]; [user, password] _ UserCredentials.Get[]; STP.Login[stpH, user, password]; }; IF NOT STP.IsOpen[stpH] THEN { [] _ STP.Open[stpH, data.serverPupName]; }; ConditionConnection[stpH, pattern, justNames]; }; ReturnConnection: PROC [h: ServerHandle, stpH: STP.Handle] ~ { data: ServerData ~ NARROW[h.data]; ReturnConnectionInner: ENTRY PROC ~ --INLINE-- { IF data.stpH = NIL THEN { data.stpH _ stpH; stpH _ NIL }; data.connectionTTL _ initialConnectionTTL; }; ReturnConnectionInner[]; IF stpH # NIL THEN { STP.Close[stpH ! STP.Error => CONTINUE ]; }; }; STPValidate: ENTRY FSRemoteFileBackdoor.ValidateProc -- [h: ServerHandle] RETURNS [obsolete: BOOL, down: BOOL] -- ~ { data: ServerData ~ NARROW[h.data]; IF (data.ttl = 0) AND data.downMsg # NIL THEN RETURN [TRUE, data.downMsg]; RETURN [FALSE, data.downMsg]; }; SetServerDown: ENTRY PROC [h: ServerHandle, seconds: CARD] ~ { data: ServerData ~ NARROW[h.data]; data.downMsg _ "got STP error"; data.ttl _ seconds; }; dfq: SafeStorage.FinalizationQueue ~ SafeStorage.NewFQ[20]; STPSweep: FSRemoteFileBackdoor.SweepProc -- [h: ServerHandle, seconds: CARD] -- ~ { data: ServerData ~ NARROW[h.data]; stpH: STP.Handle _ NIL; STPSweepInner: ENTRY PROC ~ --INLINE-- { IF data.ttl > seconds THEN data.ttl _ data.ttl - seconds ELSE data.ttl _ 0; IF data.connectionTTL > seconds THEN data.connectionTTL _ data.connectionTTL - seconds ELSE { IF data.connectionTTL > 0 THEN stpH _ data.stpH; data.stpH _ NIL; data.connectionTTL _ 0; }; }; STPSweepInner[]; IF (stpH # NIL) AND (STP.IsOpen[stpH]) THEN STP.Close[stpH ! STP.Error => CONTINUE]; <> WHILE NOT SafeStorage.FQEmpty[dfq] DO droppedData: ServerData ~ NARROW[SafeStorage.FQNext[dfq]]; IF ((stpH _ droppedData.stpH) # NIL) AND (STP.IsOpen[stpH]) THEN STP.Close[stpH ! STP.Error => CONTINUE]; ENDLOOP; }; <> <> GrapevineCacheEntry: TYPE = RECORD[ name: ROPE _ NIL, connect: GVBasics.Connect ]; GrapevineCacheArray: TYPE = ARRAY [0..maxGrapevineCache) OF GrapevineCacheEntry; grapevineCache: REF GrapevineCacheArray _ NEW[GrapevineCacheArray]; grapevineCachePut: CARDINAL _ 0; -- next victim FindInGrapevineCache: ENTRY PROC [name: ROPE] RETURNS [found: BOOL _ FALSE, connect: GVBasics.Connect _ NIL] = { ENABLE UNWIND => NULL; FOR i: CARDINAL IN [0..maxGrapevineCache) DO IF Rope.Equal[name, grapevineCache[i].name, FALSE] THEN RETURN[TRUE, grapevineCache[i].connect]; ENDLOOP; }; AddToGrapevineCache: ENTRY PROC [name: ROPE, connect: GVBasics.Connect] = { ENABLE UNWIND => NULL; grapevineCache[grapevineCachePut].name _ name; grapevineCache[grapevineCachePut].connect _ connect; grapevineCachePut _ (IF grapevineCachePut < (maxGrapevineCache-1) THEN grapevineCachePut+1 ELSE 0); }; <> GetConnectResult: TYPE ~ REF GetConnectResultObject; GetConnectResultObject: TYPE ~ RECORD [ done: BOOL _ FALSE, waitForDone: CONDITION, info: GVNames.ConnectInfo, connect: GVBasics.Connect ]; WaitForDone: ENTRY PROC [r: GetConnectResult] ~ { ENABLE UNWIND => NULL; WHILE NOT r.done DO WAIT r.waitForDone ENDLOOP; }; NotifyDone: ENTRY PROC [r: GetConnectResult] ~ { ENABLE UNWIND => NULL; r.done _ TRUE; NOTIFY r.waitForDone; }; GetServerPupName: PUBLIC PROC [server: ROPE] RETURNS [pupServer: ROPE] ~ { IF Rope.Find[server, ".", 0] < 0 THEN RETURN [server]; <> { foundInCache: BOOL; connect: GVBasics.Connect; r: GetConnectResult; [foundInCache, connect] _ FindInGrapevineCache[server]; IF foundInCache THEN RETURN[connect]; r _ NEW[GetConnectResultObject]; TRUSTED { Process.EnableAborts[@r.waitForDone]; Process.Detach[FORK DoGetConnect[server, r]]; -- sets r.info, r.connect }; WaitForDone[r]; <> IF (r.info = group) OR (r.info = individual) THEN { AddToGrapevineCache[name~server, connect~r.connect]; RETURN[r.connect]; }; }; }; DoGetConnect: PROC [server: ROPE, r: GetConnectResult] ~ { [r.info, r.connect] _ GVNames.GetConnect[server]; NotifyDone[r]; }; <> 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: STP.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]; }; }; <> CheckUnimplemented: PROC [h: ServerHandle, file: ROPE, case: BOOL] ~ { IF Rope.FindBackward[file, "!"] < 0 THEN ERROR; -- for now IF case THEN ERROR; -- for now }; ReportSTPError: PROC [stpCode: STP.ErrorCode, h: ServerHandle, file: ROPE, time: GMT] ~ { gName: ROPE _ Rope.Cat["[", h.name, "]", file]; quotedGName: ROPE _ Rope.Cat["\"", gName, "\""]; OldError: PROC [code: FSBackdoor.ErrorCode, e1, e2: ROPE, downTime: CARD] ~ { IF downTime > 0 THEN SetServerDown[h, downTime]; FSBackdoor.ProduceError[code, Rope.Cat[(IF e1 # NIL THEN e1 ELSE "Server for "), quotedGName, e2]]; }; NewError: PROC [group: FS.ErrorGroup, code: ATOM, e1, e2: ROPE, downTime: CARD] ~ { IF downTime > 0 THEN SetServerDown[h, downTime]; ERROR FS.Error[[group, code, Rope.Cat[(IF e1 # NIL THEN e1 ELSE "Server for "), quotedGName, e2]]]; }; SELECT stpCode FROM noRouteToNetwork, noNameLookupResponse => OldError[serverInaccessible, NIL, " is inaccessible", downServerTTL]; connectionClosed => OldError[wentOffline, NIL, " connection closed unexpectedly (wentOffline)", downServerTTL]; connectionRejected => OldError[connectionRejected, NIL, " rejected the connection attempt", busyServerTTL]; connectionTimedOut => OldError[connectionTimedOut, NIL, " timed-out the connection", 0]; accessDenied => OldError[accessDenied, NIL, " denied file access permission", 0]; requestRefused => OldError[quotaExceeded, "Request refused (possibily no quota for storing) for ", NIL, 0]; accessError => OldError[fileBusy, "File ", " is locked on the server", 0]; illegalUserName => OldError[badCredentials, "Credentials rejected when accessing ", NIL, credentialsErrorTTL]; illegalFileName => OldError[illegalName, NIL, " says that the file name is illegal", 0]; noSuchHost => OldError[unknownServer, "Couldn't find the server for ", NIL, downServerTTL]; alreadyAConnection => NewError[bug, $alreadyAConnection, NIL, " already had a connection", 0]; noConnection => NewError[bug, $noConnection, NIL, " gave a noConnection error", 0]; illegalUserPassword => NewError[environment, $illegalUserPassword, NIL, " had an illegal user password", credentialsErrorTTL]; illegalUserAccount => NewError[environment, $illegalUserAccount, NIL, " had an illegal user account", credentialsErrorTTL]; illegalConnectName => NewError[environment, $illegalConnectName, NIL, " had an illegal connect name", credentialsErrorTTL]; illegalConnectPassword => NewError[environment, $illegalConnectPassword, NIL, " had an illegal connect password", credentialsErrorTTL]; credentailsMissing => NewError[environment, $credentailsMissing, NIL, " had missing credentails", credentialsErrorTTL]; protocolError => NewError[bug, $protocolError, NIL, " gave a protocol error to STP", 0]; noSuchFile => { FSReport.UnknownFile[gName, time]; -- raises FS.Error }; undefinedError => NewError[bug, $undefinedError, NIL, " gave STP an undefinedError", 0]; ENDCASE => ERROR; }; <> SafeStorage.EstablishFinalization[type~CODE[STPFSRemoteFile.ServerDataObject], npr~0, fq~dfq]; FSRemoteFileBackdoor.Register[myFlavor, STPGetServer]; }. <> <> <> <> <<>> <> <> <> <> <<>> <> <> <<>> <> <> <> <<>> <<>> <<>>