file: STPsB.mesa - Simple/Stream Transfer Protocol
Traditional FTP-like interface stuff in here
Edited by:
Smokey, 17-Jul-81 7:48:31
JGS, 17-Aug-81 11:26:24
Karlton, 15-Mar-82 17:26:37
Loretta, 10-Nov-81 16:07:59
Davirro, 24-Sep-82 10:35:49
Daniels, 21-Sep-82 13:05:55
Andrew Birrell, June 1, 1983 3:51 pm
Last Edited by: Schroeder, December 7, 1983 10:40 am
DIRECTORY
BasicTime USING [GMT],
IO USING [EndOf, EndOfStream, Error, GetBlock, GetChar, GetIndex, PutBlock, SetIndex, STREAM],
PupStream USING [CloseReason, ConsumeMark, PupByteStreamAbort, SendMark, StreamClosing, TimeOut],
Rope USING [ROPE],
STP USING [
Close, Completion, CompletionProcType, Confirmation, ConfirmProcType,
CredentialsErrors, Error, ErrorCode, FileErrors, NoteFileProcType, Type],
STPOps USING [
CheckConnection, CollectCode, CollectString, ErrorIfNextNotYes, ErrorIfNextNotEOC,
ErrorCodeToSTPErrorCode,
GenerateErrorString, GenerateProtocolError, GenerateStreamClosingError, GetCommand,
GetHereIsAndPList, GetPList, Handle, LookAtMark, MarkEncountered,
MakeRemoteName, markComment, markDelete,
markDirectory, markEOC, markHereIsFile, markHereIsPList, markNo, markNewDirectory,
markNewStore, markRename,
markRetrieve, markYes, MyGetMark, NameToPList, Object, Operation, PList,
PutCommand, PutPList, ResetPList, SelectError, SetByteSize, SetCreateTime,
SetFileType, UserStateToPList],
STPReplyCode USING[ReplyCode];
STPsB: CEDAR PROGRAM
IMPORTS IO, PupStream, STP, STPOps
EXPORTS STP, STPOps =
BEGIN OPEN PupStream, STPOps;
Data and types
Object: PUBLIC TYPE = STPOps.Object;
Procedures for normal FTP-like interface
Delete: PUBLIC PROCEDURE [
stp: STPOps.Handle, name: Rope.ROPE, confirm: STP.ConfirmProcType,
complete: STP.CompletionProcType] =
BEGIN DoFiles[stp, name, confirm, complete, delete]; END;
Enumerate: PUBLIC PROCEDURE [
stp: STPOps.Handle, name: Rope.ROPE, proc: STP.NoteFileProcType] =
BEGIN
Foo1: STP.ConfirmProcType =
BEGIN
RETURN[answer: IF proc[file] = yes THEN do ELSE abort, localStream: NIL];
END;
Foo2: STP.CompletionProcType = BEGIN END;
DoFiles[stp, name, Foo1, Foo2, directory];
END;
Rename: PUBLIC PROCEDURE [
stp: STPOps.Handle, old, new: Rope.ROPE] =
BEGIN
mark, saveMark: [0..256);
code: CHARACTER ← 0C;
CheckConnection[stp];
ResetPList[stp.plist];
UserStateToPList[stp];
NameToPList[stp.plist, old, alto];
PutPList[stp, markRename, FALSE];
ResetPList[stp.plist];
UserStateToPList[stp];
NameToPList[stp.plist, new, alto];
PutPList[stp, 0B];
[saveMark, code, stp.remoteString] ← GetCommand[stp];
IF (mark ← MyGetMark[stp]) # markEOC THEN
GenerateProtocolError[stp, eocExpected, mark];
IF saveMark # markYes THEN
GenerateErrorString[stp, requestRefused, stp.remoteString, code];
END;
Retrieve: PUBLIC PROCEDURE [
stp: STPOps.Handle, file: Rope.ROPE, confirm: STP.ConfirmProcType ← NIL,
complete: STP.CompletionProcType ← NIL] =
BEGIN DoFiles[stp, file, confirm, complete, retrieve]; END;
Store: PUBLIC PROCEDURE [
stp: STPOps.Handle, file: Rope.ROPE, stream: IO.STREAM,
noteFile: STP.NoteFileProcType ← NIL,
fileType: STP.Type, creation: BasicTime.GMT] =
BEGIN
Confirm: STP.ConfirmProcType =
{IF noteFile = NIL OR noteFile[file] = yes THEN
RETURN[do, stream] ELSE RETURN[skip, NIL]};
CheckConnection[stp];
ResetPList[stp.plist];
UserStateToPList[stp];
NameToPList[stp.plist, file, alto];
IF fileType = unknown THEN fileType ← FindFileType[stream];
SetFileType[stp, fileType];
STPOps.SetByteSize[stp, fileType];
STPOps.SetCreateTime[stp, creation];
DoFiles[stp, file, Confirm, NIL, store];
END;
common routine for Delete, Enumerate and Retrieve
DoFiles: PUBLIC PROCEDURE [
stp: STPOps.Handle, file: Rope.ROPE, confirm: STP.ConfirmProcType,
complete: STP.CompletionProcType, op: STPOps.Operation] =
BEGIN
reason: PupStream.CloseReason;
reply: STP.Confirmation;
string: Rope.ROPE ← NIL;
local: IO.STREAM ← NIL;
killConnection: BOOLEAN ← TRUE;
CleanUp: PROCEDURE =
BEGIN
IF killConnection THEN SmashClosed[stp];
END;
{ENABLE {
PupStream.StreamClosing => {reason ← why; GOTO streamClosing};
PupStream.TimeOut => {reason ← transmissionTimeout; GOTO streamClosing};
UNWIND => CleanUp[]};
IF op # store THEN
BEGIN
CheckConnection[stp];
ResetPList[stp.plist];
UserStateToPList[stp];
NameToPList[stp.plist, file, alto];
END;
IF op = directory THEN
SELECT TryNewDirectory[stp, confirm ! STP.Error =>
IF code IN STP.CredentialsErrors OR code IN STP.FileErrors THEN
killConnection ← FALSE] FROM
finished => RETURN;
aborted => {CleanUp[]; RETURN};
tryOldDirectory => NULL; -- just falls thru
ENDCASE => ERROR;
PutPList[
stp,
SELECT op FROM
delete => markDelete,
directory => markDirectory,
retrieve => markRetrieve,
store => markNewStore,
ENDCASE => ERROR];
DO
IF LookAtMark[stp] = markEOC THEN {[] ← MyGetMark[stp]; EXIT};
GetHereIsAndPList[stp, op # directory ! STP.Error =>
IF code IN STP.CredentialsErrors OR code IN STP.FileErrors THEN
killConnection ← FALSE];
SELECT TRUE FROM
confirm = NIL => {reply ← do; local ← NIL};
ENDCASE => [reply, local] ← confirm[string ← MakeRemoteName[stp.plist, alto]];
SELECT reply FROM
do => {
completion: STP.Completion;
SELECT op FROM
delete => {
code: CHARACTER ← 0C;
mark: [0..256);
PutCommand[stp, markYes, 0C, "Yes, please"];
[mark, code, stp.remoteString] ← GetCommand[stp];
SELECT mark FROM
markYes => completion ← ok;
markNo => IF complete = NIL
THEN GenerateErrorString[stp, requestRefused, stp.remoteString, code]
ELSE completion ← error;
ENDCASE => GenerateErrorString[stp, protocolError, stp.remoteString, code]};
retrieve => {
code: CHARACTER ← 0C;
gotIt: BOOLEAN;
PutCommand[stp, markYes, 0C, "Yes, please"];
[gotIt, code] ← GetFile[stp, local, stp.plist[nameBody]];
completion ← IF gotIt THEN ok ELSE error;
IF completion = error AND complete = NIL
THEN GenerateErrorString[stp, requestRefused, stp.remoteString, code]};
store => {
PutFile[stp, local, stp.plist[nameBody]];
ErrorIfNextNotYes[stp]};
ENDCASE;
IF complete # NIL THEN complete[completion, stp.remoteString];
IF LookAtMark[stp] = markEOC THEN {[] ← MyGetMark[stp]; EXIT}};
skip => {
IF op # directory THEN
PutCommand[stp, markNo, 106C, "No Thanks"];
IF op = store THEN {
mark: [0..256);
code: CHARACTER;
[mark, code, stp.remoteString] ← GetCommand[stp];
IF mark # markNo THEN
GenerateErrorString[stp, protocolError, stp.remoteString, code]};
};
abort => {CleanUp[]; RETURN};
ENDCASE => ERROR;
ResetPList[stp.plist];
ENDLOOP;
EXITS
streamClosing => GenerateStreamClosingError[stp, reason]};
END;
TryNewDirectory: PROC[stp: STPOps.Handle, confirm: STP.ConfirmProcType]
RETURNS[{finished, aborted, tryOldDirectory}] = {
mark: [0..256);
PutPList[stp, markNewDirectory];
DO
SELECT (mark ← MyGetMark[stp]) FROM
markComment => stp.remoteString ← CollectString[stp];
markHereIsPList => {
string: Rope.ROPE;
reply: STP.Confirmation;
DO
GetPList[stp: stp, gobbleEOC: FALSE, propertiesOk: TRUE
! MarkEncountered => {
mark: [0..256) ← LookAtMark[stp];
IF mark = markEOC THEN EXIT
ELSE GenerateProtocolError[stp, eocExpected, mark]
}];
string ← MakeRemoteName[stp.plist, alto];
[answer: reply] ← confirm[string];
IF reply = abort THEN RETURN[aborted];
ENDLOOP;
ErrorIfNextNotEOC[stp];
RETURN[finished];
};
markNo =>
BEGIN
code: CHARACTER = CollectCode[stp];
errorCode: STP.ErrorCode =
ErrorCodeToSTPErrorCode[requestRefused, code];
stp.remoteString ← CollectString[stp];
ErrorIfNextNotEOC[stp];
IF LOOPHOLE[code, STPReplyCode.ReplyCode] = badCommand THEN
RETURN[tryOldDirectory];
GenerateErrorString[stp, errorCode, stp.remoteString, code];
END;
ENDCASE => GenerateProtocolError[stp, badMark, mark, 0C];
ENDLOOP;
};
Procedures for doing FTP protocol operations
GetFile: PUBLIC PROCEDURE [
stp: STPOps.Handle, stream: IO.STREAM, file: Rope.ROPE]
RETURNS[gotIt: BOOLEAN, code: CHARACTER] =
BEGIN
mark: [0..256);
CheckConnection[stp];
SELECT (mark ← MyGetMark[stp]) FROM
markHereIsFile => NULL;
markNo => {
code ← CollectCode[stp];
stp.remoteString ← CollectString[stp];
gotIt ← FALSE;
RETURN};
ENDCASE => SelectError[stp, "HereIsFile Expected", mark];
TransferTheFile[stp: stp, from: stp.byteStream, to: stream];
stp.mark ← PupStream.ConsumeMark[stp.byteStream];
stp.gotMark ← TRUE;
ErrorIfNextNotYes[stp]; -- should do something about file on local disk
gotIt ← TRUE;
RETURN
END;
PutFile: PUBLIC PROCEDURE [
stp: STPOps.Handle, stream: IO.STREAM, file: Rope.ROPE, sendEOC: BOOLEAN ← TRUE] =
BEGIN
CheckConnection[stp];
PupStream.SendMark[stp.byteStream, markHereIsFile];
TransferTheFile[stp: stp, from: stream, to: stp.byteStream];
PutCommand[stp, markYes, 0C, "Transfer Completed", sendEOC];
END;
TransferTheFile: PROCEDURE [stp: STPOps.Handle, from, to: IO.STREAM] =
BEGIN
buffer: REF TEXT = NEW[TEXT[1024]];
buffer.length ← buffer.maxLength;
DO nBytes: NAT = from.GetBlock[buffer, 0, buffer.maxLength];
to.PutBlock[buffer, 0, nBytes];
IF from.EndOf[] THEN EXIT;
ENDLOOP;
END;
SmashClosed: PUBLIC PROCEDURE [stp: STPOps.Handle] =
BEGIN
IF stp = NIL OR stp.byteStream = NIL THEN RETURN;
First smash connection so it will not give us any grief, THEN close it
PupStream.PupByteStreamAbort[stp.byteStream, "Unwinding..."];
STP.Close[stp ! STP.Error => IF code = noConnection THEN CONTINUE];
END;
FindFileType: PUBLIC PROCEDURE [stream: IO.STREAM]
RETURNS [fileType: STP.Type] =
BEGIN
ENABLE IO.Error => IF ec = NotImplementedForThisStream THEN GOTO unknown;
currentIndex: INT = stream.GetIndex[];
stream.SetIndex[0];
fileType ← text;
DO IF stream.GetChar[ ! IO.EndOfStream => EXIT] > 177C THEN {fileType ← binary; EXIT};
ENDLOOP;
stream.SetIndex[currentIndex];
EXITS unknown => fileType ← unknown;
END;
END. -- of STPsB