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;


Object: PUBLIC TYPE = STPOps.Object;


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;


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;
};


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;
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


‚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
Data and types
Procedures for normal FTP-like interface 
common routine for Delete, Enumerate and Retrieve
Procedures for doing FTP protocol operations  
First smash connection so it will not give us any grief, THEN close it
�Ê
Ù˜Jš
œ3™3Jš
œ,™,Jš
œ
™
Jš
œ!™!Jš
œ&™&Jš
œ"™"Jš
œ"™"Jš
œ"™"Jš
œ"™"Jš
œ$™$J™4š
Ïk	˜	Jšœ
�œ�œ˜Jš�œ
�œN�œ˜^Jšœ
�œR˜aJšœ�œ�œ˜š�œ
�œ˜J˜EJ˜I—šœ�œ˜J˜RJ˜J˜SJ˜BJ˜(J˜SJ˜J˜HJ˜JJ˜—Jšœ
�œ˜J˜—šœ�œ
�˜Jš�œ
�œ
�œ˜"Jš�œ
�œ
˜Jš�œ
�œ˜J˜—Jš
œ™˜Jšœ�œ
�œ˜$J˜—Jš
œ)™)˜šÏnœ�œ
�	œ˜Jšœ�œ�œ˜BJšœ
�œ˜#Jš�œ0�œ
˜9J˜—šž	œ�œ
�	œ˜Jšœ�œ�œ˜BJš
�˜šœ�œ˜Jš
�˜Jš
�œ	�œ�œ�œ�œ˜IJš�œ
˜—Jšœ�œ�œ
�œ
˜)J˜*Jš�œ
˜J˜—šžœ�œ
�	œ˜Jšœ#�œ˜*Jš
�˜J˜Jšœ�	œ˜J˜J˜J˜J˜"Jšœ�œ˜!J˜J˜J˜"J˜J˜5š�œ#�˜)J˜.—š�œ�˜J˜A—Jš�œ
˜J˜—šžœ�œ
�	œ˜Jšœ�œ�œ�œ
˜HJšœ
�œ�œ˜)Jš�œ2�œ
˜;J˜—šžœ�œ
�	œ˜Jšœ�œ
�œ
�œ
˜7Jšœ
�œ�œ
˜%Jšœ
�œ�œ˜.Jš
�˜šœ	�œ˜Jšœ
�œ�œ
�œ�˜/Jš�œ
�œ
�œ�œ˜+—J˜J˜J˜J˜#Jš�œ�œ!˜;J˜J˜"J˜$Jšœ�œ	˜(Jš�œ
˜J˜——Jš
œ1™1˜šžœ�œ
�	œ˜Jšœ�œ�œ˜BJšœ
�œ,˜9Jš
�˜J˜Jšœ�œ˜Jšœ
�œ�œ
˜Jšœ�œ
�œ�œ
˜Jšœ�œ�œ
˜šžœ�	œ˜Jš
�˜Jš�œ�œ˜(Jš�œ
˜—šœ
�œ˜	Jšœ*�œ˜>Jšœ4�œ˜HJš�œ˜—š�œ�˜Jš
�˜J˜J˜J˜J˜#Jš�œ
˜—š�œ�œ
˜š�œ!�œ	˜3š�œ�œ
�œ�œ�œ
�œ�œ
˜@Jšœ�œ�˜——Jšœ�œ
˜Jšœ�œ
˜'Jšœ�œ	Ïc˜2Jš�œ�œ
˜—˜	J˜š�œ�˜J˜J˜J˜J˜Jš�œ�œ˜—š
�˜Jš�œ�œ�œ˜>šœ(�œ	˜4š�œ�œ
�œ�œ�œ
�œ�œ
˜@Jšœ�œ˜——š�œ
�œ
�˜Jšœ
�œ�œ˜+Jš�œG˜N—š�œ�˜˜Jšœ�œ˜š�œ�˜˜Jšœ�	œ˜J˜J˜,J˜1š�œ�˜J˜šœ
�œ�˜Jš�œA˜EJš�œ˜—Jš�œE˜L——˜
Jšœ�	œ˜Jšœ�œ
˜J˜,Jš
œ9˜9Jšœ
�œ�œ�œ˜)Jš�œ�œ�˜(Jš�œC˜G—˜
J˜)J˜—Jš�œ
˜—Jš�œ�œ
�œ(˜>Jš�œ�œ�œ˜?—˜	š�œ�˜J˜+—š�œ�œ˜J˜Jšœ�	œ
˜J˜1š�œ�˜J˜A——J˜—Jšœ�œ˜Jš�œ�œ
˜—J˜Jš�œ
˜—š
�˜J˜:—Jš�œ
˜J˜———šžœ�œ�œ˜HJš�œ*˜1J˜J˜ š
�˜Jš�œ�˜#J˜5˜Jšœ
�œ
˜Jšœ�œ˜š
�˜šœ�œ�˜7˜J˜!Jš�œ�œ
�˜Jš�œ.˜2J˜——J˜)J˜"Jš�œ�œ
�œ
˜&Jš�œ
˜—J˜Jš�œ˜J˜—˜	Jš
�˜Jšœ�	œ˜#šœ�œ˜J˜/—J˜&J˜š�œ
�œ,�˜;Jš�œ˜—J˜<Jš�œ
˜—Jš�œ2˜9Jš�œ
˜—J˜J˜—Jš
œ.™.˜šžœ�œ
�	œ˜Jšœ�œ
�œ
�œ
˜7Jš�œ�œ�	œ˜*Jš
�˜J˜J˜š�œ�˜#Jšœ�œ
˜˜Jš
œ˜Jš
œ&˜&Jšœ�œ
˜Jš�œ˜—Jš�œ2˜9—J˜<J˜1Jšœ�œ
˜JšœŸ/˜GJšœ�œ
˜
Jš
�˜Jš�œ
˜J˜—šžœ�œ
�	œ˜Jšœ�œ
�œ
�œ�œ�œ˜RJš
�˜J˜J˜3J˜<J˜<Jš�œ
˜J˜—šžœ�	œ �œ
�œ˜FJš
�˜Jš	œ�œ
�œ�œ
�œ˜#J˜!š�œ	�œ.˜<J˜Jš�œ�œ
�œ
˜—Jš�œ
˜Jš�œ
˜J˜—šžœ�œ
�	œ˜4Jš
�˜Jš�œ�œ
�œ�œ
�œ
�œ
˜1Jš
œF™FJ˜=Jš
�œ
�œ
�œ�œ
�œ˜CJš�œ
˜J˜—š
žœ�œ
�	œ
�œ
�œ
˜2Jš�œ�œ˜Jš
�˜Jš
�œ
�œ
�œ"�œ
�œ	˜IJšœ�œ˜&J˜J˜Jš�œ
�œ�œ�œ	�œ�œ˜VJš�œ
˜J˜Jš�œ˜$Jš�œ
˜J˜—Jš�œŸ˜J˜J˜——…—#0o