
    <<STPsD.mesa - Simple/Stream Transfer Protocol (Common and protocol)>>
        <<Copyright © 1985 by Xerox Corporation.  All rights reserved.>>
        <<Mark, Feb 12, 1981 11:39 PM>>
        <<Smokey, 17-Jul-81  7:20:16>>
        <<Karlton, 17-Jul-81 17:45:12>>
        <<JGS, 14-Aug-81 10:35:26>>
        <<Loretta, 27-Oct-82 10:45:58>>
        <<Daniels, 21-Sep-82 13:07:12>>
        <<Davirro, 15-Dec-82 15:32:52>>
        <<Andrew Birrell, June 1, 1983 5:39 pm>>
        <<Levin, August 9, 1983 9:59 am>>
        <<Schroeder, August 10, 1983 5:33 pm, but I only changed one character!>>
        <<MBrown, September 17, 1983 8:14 pm>>
        <<HGM, February 20, 1984 10:29:03 pm PST>>
        <<Russ Atkinson (RRA) April 4, 1985 11:40:25 am PST>>

    DIRECTORY
        BasicTime USING[ GMT, MonthOfYear, Unpack, Unpacked ],
        Convert USING[ IntFromRope ],
        IO USING[ EndOf, EndOfStream, GetBlock, GetChar, STREAM, PutChar, PutF, PutRope, ROS, RopeFromROS ],
        PupStream USING[ConsumeMark, SendMark, StreamClosing, TimeOut],
        Rope USING [Cat, Equal, Fetch, Find, FromRefText, Length, ROPE, Substr],
        STP USING [DesiredProperties, Error, ErrorCode, FileInfo, Open, Type],
        STPOps USING [DestroyPList, ErrorCodeToSTPErrorCode, FileProperties, FilenameType, GenerateErrorString, GenerateProtocolError, 
        Handle, markAbort, markComment,         markEOC, markHereIsPList, markIAmVersion, markNo, markYes, markYouAreUser, Object, 
        PList, PListArray, ServerType, SmashClosed, UserProperties, ValidProperties];

    STPsD: CEDAR PROGRAM
        IMPORTS BasicTime, Convert, IO, PupStream, Rope, STP, STPOps
        EXPORTS STP, STPOps =
        { OPEN STPOps;

        <<Exported Types>>

        Object: PUBLIC TYPE = STPOps.Object;

        <<Global Data>>

        MarkEncountered: PUBLIC ERROR = CODE;
        BadProperty: PUBLIC ERROR = CODE;
        propertyStrings: PListArray = [
            userName: "User-Name", userPassword: "User-Password",
            connectName: "Connect-Name", connectPassword: "Connect-Password",
            byteSize: "Byte-Size", type: "Type", size: "Size", directory: "Directory",
            nameBody: "Name-Body", version: "Version", createDate: "Creation-Date",
            readDate: "Read-Date", writeDate: "Write-Date", author: "Author",
            eolConversion: "End-of-Line-Convention", account: "Account",
            userAccount: "User-Account", device: "Device",
            serverName: "Server-Filename"];
        desiredPropString: Rope.ROPE = "Desired-property";

    <<Commonly used stuff  >>

        Connect: PUBLIC PROC [stp: STPOps.Handle, name, password: Rope.ROPE] = {
            stp.userState[connectName] _ name;
            stp.userState[connectPassword] _ password;
            };

        IsOpen: PUBLIC PROC [stp: STPOps.Handle] RETURNS [yes: BOOL] = {
            yes _ stp.byteStream # NIL};

        GetProperty: PUBLIC PROC [stp: STPOps.Handle, prop: ValidProperties] RETURNS [Rope.ROPE] = {
            RETURN[stp.plist[prop]]};

        Login: PUBLIC PROC [stp: STPOps.Handle, name, password: Rope.ROPE] = {
            stp.userState[userName] _ name;
            stp.userState[userPassword] _ password;
            };

        SetHost: PUBLIC PROC [stp: STPOps.Handle, host: Rope.ROPE] = {
            stp.host _ host };

        SetDirectory: PUBLIC PROC [stp: STPOps.Handle, directory: Rope.ROPE] = {
            stp.userState[directory] _ directory };

    <<Procedures for doing FTP protocol operations  >>

        GetCommand: PUBLIC PROC [stp: STPOps.Handle] RETURNS [mark: [0..256), code: CHARACTER, ps: Rope.ROPE] = {
            code _ 0C;
            CheckConnection[stp];
            mark _ MyGetMark[stp];
            SELECT mark FROM
                markAbort, markComment, markYouAreUser => ps _ CollectString[stp];
                markIAmVersion, markNo, markYes => {code _ CollectCode[stp]; ps _ CollectString[stp]};
                ENDCASE => GenerateProtocolError[stp, badMark, mark, code];
            };

        GetHereIsAndPList: PUBLIC PROC [stp: STPOps.Handle, gobbleEOC: BOOL _ TRUE] = {
            mark: [0..256);
            DO
                SELECT (mark _ MyGetMark[stp]) FROM
                    markComment => stp.remoteString _ CollectString[stp];
                    markHereIsPList => {GetPList[stp, gobbleEOC, FALSE]; EXIT};
                    markNo =>
                        {
                        code: CHARACTER = CollectCode[stp];
                        errorCode: STP.ErrorCode = ErrorCodeToSTPErrorCode[requestRefused, code]; 
                        stp.remoteString _ CollectString[stp];
                        ErrorIfNextNotEOC[stp];
                        GenerateErrorString[stp, errorCode, stp.remoteString, code];
                        };
                    ENDCASE => GenerateProtocolError[stp, badMark, mark, 0C];
                ENDLOOP;
            };

        GetPList: PUBLIC PROC [stp: STPOps.Handle, gobbleEOC: BOOL, propertiesOk: BOOL] = {
            buffer: REF TEXT = NEW[TEXT[100]]; -- arbitrary choice of length
            Record: PROC = {
                IF buffer.length # 0
                THEN {
                    fragment: Rope.ROPE = Rope.FromRefText[buffer];
                    buffer.length _ 0;
                    IF which = property
                    THEN property _ property.Cat[fragment]
                    ELSE value _ value.Cat[fragment];
                    };
                };
            Append: PROC[c: CHAR] = {
                IF buffer.length = buffer.maxLength THEN Record[];
                buffer[buffer.length] _ c; buffer.length _ buffer.length+1;
                };
            property: Rope.ROPE;
            value: Rope.ROPE;
            parens: INT _ 0;
            char: CHARACTER;
            which: {property, value} _ property;
            CheckConnection[stp];
            stp.plist[nameBody] _ NIL;
            DO
                char _ MyGetChar[stp ! MarkEncountered => IF NOT propertiesOk THEN GOTO BadPList];
                SELECT char FROM
                    '' =>
                        Append[MyGetChar[stp ! MarkEncountered => GOTO BadPList]];
                    '( =>
                        { parens _ parens + 1; Record[]; which _ property; property _ NIL; };
                    '  =>
                        IF which = property THEN { Record[]; which _ value; value _ NIL; }
                        ELSE Append[char];
                    ') =>
                        {
                        Record[];
                        IF property.Length[] # 0 AND value.Length[] # 0 THEN
                            {
                            SetPListItem[
                                stp.plist, property, value ! BadProperty => CONTINUE];
                            property _ value _ NIL;
                            };
                        IF (parens _ parens - 1) = 0 THEN EXIT;
                        };
                    ENDCASE => Append[char];
                ENDLOOP;
            IF (property.Length[] # 0 AND value.Length[] # 0) THEN GOTO BadPList;
            IF gobbleEOC AND MyGetMark[stp] # markEOC THEN GOTO BadPList;
            EXITS
                BadPList => {ResetPList[stp.plist]; GenerateProtocolError[stp, badPList, stp.mark]};
            };

        PutCommand: PUBLIC PROC [stp: STPOps.Handle, mark: [0..256), code: CHARACTER, string: Rope.ROPE, sendEOC: BOOL _ TRUE] = {
            CheckConnection[stp];
            PupStream.SendMark[stp.byteStream, mark];
            stp.byteStream.PutChar[code];
            IF string.Length[] # 0 THEN MyPutString[stp.byteStream, string];
            IF sendEOC THEN PupStream.SendMark[stp.byteStream, markEOC];
            };

        PutPList: PUBLIC PROC [stp: STPOps.Handle, mark: [0..256), sendEOC: BOOL _ TRUE] = {
            state: {okay, tryOpen, triedOpen} _ okay;
            DoIt: PROC = {
                CheckConnection[stp];
                IF mark # 0B THEN PupStream.SendMark[stp.byteStream, mark];
                stp.byteStream.PutChar['(];
                FOR i: ValidProperties IN ValidProperties DO
                    IF stp.plist[i].Length[] # 0 THEN
                        PutPListItem[stp.byteStream, i, stp.plist[i]];
                    ENDLOOP;
                IF stp.desiredProps # ALL[TRUE] THEN PutDesiredProps[stp];
                stp.byteStream.PutChar[')];
                IF sendEOC THEN PupStream.SendMark[stp.byteStream, markEOC];
                };
            DO
                DoIt[! PupStream.StreamClosing, PupStream.TimeOut =>
                    IF state = okay AND stp.host.Length[] # 0 THEN
                        {state _ tryOpen; CONTINUE}];
                IF state # tryOpen THEN EXIT;
                {
                    savedPList: PList _ stp.plist;
                    stp.plist _ NIL;
                    SmashClosed[stp];  -- Call outside catch so Pup monitor unlocked
                    [] _ STP.Open[stp, stp.host];
                    stp.plist _ DestroyPList[stp.plist];
                    stp.plist _ savedPList;
                    state _ triedOpen;
                    };
                ENDLOOP;
            };

    <<Utility routines>>

        CollectString: PUBLIC PROC [stp: STPOps.Handle] RETURNS[ r: Rope.ROPE _ NIL] = {
            buffer: REF TEXT = NEW[TEXT[100]]; -- arbitrary choice of length
            DO buffer.length _ stp.byteStream.GetBlock[buffer, 0, buffer.maxLength];
                r _ r.Cat[Rope.FromRefText[buffer]];
                IF stp.byteStream.EndOf[] THEN EXIT;
            ENDLOOP;
            stp.mark _ PupStream.ConsumeMark[stp.byteStream];
            stp.gotMark _ TRUE;
            SELECT stp.mark FROM
                markHereIsPList, markEOC => NULL;
            ENDCASE => GenerateProtocolError[stp, eocExpected, stp.mark];
            };

        CollectCode: PUBLIC PROC [stp: STPOps.Handle] RETURNS [code: CHARACTER] = {
            code _ 0C;
            CheckConnection[stp];
            code _ MyGetChar[stp ! MarkEncountered =>
                GenerateProtocolError[stp, noCode, MyGetMark[stp]]];
            };

        CheckConnection: PUBLIC PROC [stp: STPOps.Handle] = {
            WHILE stp.byteStream = NIL DO
                SIGNAL STP.Error[stp, noConnection, "Please open a connection!", 0C] ENDLOOP
            };

        ErrorIfNextNotYes: PUBLIC PROC [stp: STPOps.Handle] = {
            code: CHARACTER _ 0C;
            mark: [0..256);
            [mark, code, stp.remoteString] _ GetCommand[stp];
            IF mark # markYes THEN GenerateErrorString[stp, requestRefused, stp.remoteString, code];
            };

        ErrorIfNextNotEOC: PUBLIC PROC [stp: STPOps.Handle] = {
            mark: [0..256) _ MyGetMark[stp];
            IF mark # markEOC THEN GenerateProtocolError[stp, eocExpected, mark];
            };

        GetServerType: PUBLIC PROC [server: Rope.ROPE] RETURNS [serverType: ServerType] = {
            RETURN[SELECT TRUE FROM
                Rope.Equal[server, "MAXC", FALSE],
                Rope.Equal[server, "MAXC2", FALSE] => tenex,
                ENDCASE => ifs];
            };

        LookAtMark: PUBLIC PROC [stp: STPOps.Handle] RETURNS [[0..256)] = {
            IF ~stp.gotMark THEN
                DO
                    [] _ MyGetChar[stp ! MarkEncountered => CONTINUE];
                    IF stp.gotMark THEN EXIT;
                    ENDLOOP;
            RETURN[stp.mark]
            };

        MyGetChar: PUBLIC PROC [stp: STPOps.Handle] RETURNS [char: CHARACTER] = {
            char _ stp.byteStream.GetChar[! IO.EndOfStream => GOTO end];
            EXITS end => {
                stp.mark _ PupStream.ConsumeMark[stp.byteStream];
                stp.gotMark _ TRUE;
                ERROR MarkEncountered;
                }
            };

        MyGetMark: PUBLIC PROC [stp: STPOps.Handle] RETURNS [mark: [0..256)] = {
            mark _ LookAtMark[stp]; stp.gotMark _ FALSE; RETURN[mark];
            };

        MyPutString: PUBLIC PROC [byteStream: IO.STREAM, string: Rope.ROPE] = {
            byteStream.PutRope[string];
            };

        MyPutStringVal: PUBLIC PROC [byteStream: IO.STREAM, string: Rope.ROPE] = {
            FOR i: INT IN [0..string.Length[]) DO
                char: CHAR = string.Fetch[i];
                SELECT char FROM
                    '(, '),  '' => byteStream.PutChar['']
                    ENDCASE => NULL;
                byteStream.PutChar[char];
                ENDLOOP;
            };

        PropertyString: PUBLIC PROC [prop: STPOps.ValidProperties] RETURNS [string: Rope.ROPE] = { RETURN[propertyStrings[prop]]; };

        SetCreateTime: PUBLIC PROC [stp: STPOps.Handle, creation: BasicTime.GMT] = {
            month: ARRAY BasicTime.MonthOfYear OF Rope.ROPE = [
                January: "Jan", February: "Feb", March: "Mar", April: "Apr", May: "May", June: "Jun", July: "Jul", August: "Aug", September: "Sep", 
                October: "Oct", November: "Nov", December: "Dec" ];
            zoneIndex: TYPE = [4 .. 10];
            zoneChars: ARRAY zoneIndex OF CHAR = ['A, 'E, 'C, 'M, 'P, 'Y, 'H]; 
            unpack: BasicTime.Unpacked = BasicTime.Unpack[creation];
            absZone: INT _ ABS[IF unpack.dst = yes THEN unpack.zone - 60 ELSE unpack.zone];
            <<Desired syntax is: "dd-mmm-yy hh:mm:ss zzz">>
            str: IO.STREAM = IO.ROS[];
            str.PutF["%02d-%g-%02d", [integer[unpack.day]], [rope[month[unpack.month]]], [integer[unpack.year MOD 100]] ];
            str.PutF[" %02d:%02d:%02d ", [integer[unpack.hour]], [integer[unpack.minute]], [integer[unpack.second]] ];
            IF (unpack.zone / 60 IN zoneIndex) AND absZone MOD 60 = 0
            THEN {
                str.PutChar[zoneChars[unpack.zone / 60]];
                str.PutChar[IF unpack.dst = yes THEN 'D ELSE 'S];
                str.PutChar['T];
                }
            ELSE str.PutF["%g%g:%02d", [character[IF unpack.zone < 0 THEN '- ELSE '+]],
                [integer[absZone/60]], [integer[absZone MOD 60]] ];
            stp.plist[createDate] _ str.RopeFromROS[];
            };

        SetFileType: PUBLIC PROC [
            stp: STPOps.Handle, fileType: STP.Type] = {
            stp.plist[type] _
                SELECT fileType FROM text => "Text", binary => "Binary", ENDCASE => NIL;
            };

        SetByteSize: PUBLIC PROC [stp: STPOps.Handle, fileType: STP.Type] = {
            stp.plist[byteSize] _
                SELECT stp.serverType FROM
                    ifs, unknown, tenex => IF fileType = text THEN NIL ELSE "8",
                    ENDCASE => ERROR STP.Error[stp, undefinedError, NIL];
            };

        StringToFileType: PUBLIC PROC [string: Rope.ROPE] RETURNS [type: STP.Type] = {
            type _ SELECT TRUE FROM
                Rope.Equal["Text", string, FALSE] => text,
                Rope.Equal["Binary", string, FALSE] => binary,
                ENDCASE => unknown;
            };

        <<PList and FileInfo Utilities>>

        NameToPList: PUBLIC PROC [plist: PList, name: Rope.ROPE, type: FilenameType] = {
            pos: INT _ 0;
            length: INT = name.Length[];
            IF pos >= length THEN RETURN;
            IF name.Fetch[pos] = '[ THEN {
                end: INT = name.Find["]"];
                IF end > pos THEN { plist[device] _ name.Substr[pos+1, end-pos-1]; pos _ end+1 };
                IF pos >= length THEN RETURN;
                };
            IF name.Fetch[pos] = '< THEN {
                end: INT = name.Find[">"];
                IF end > pos THEN { plist[directory] _ name.Substr[pos+1, end-pos-1]; pos _ end+1 };
                IF pos >= length THEN RETURN;
                };
            {
                end: INT _ name.Find["!"];
                IF end >= 0 THEN plist[version] _ name.Substr[end+1, length-end-1] ELSE end _ length;
                plist[nameBody] _ name.Substr[pos, end-pos];
                };
            };

        PListToName: PUBLIC PROC [plist: PList, type: FilenameType] RETURNS [name: Rope.ROPE _ NIL] = {
            dir: Rope.ROPE = plist[directory];
            dirLength: INT = dir.Length[];
            IF dirLength # 0 THEN
                {
                SELECT dir.Fetch[0] FROM
                    '> => name _ name.Cat[dir.Substr[1, dirLength-1]];
                    '< => name _ name.Cat[dir];
                    ENDCASE => name _ name.Cat["<", dir];
                IF dir.Fetch[dirLength - 1] # '> THEN name _ name.Cat[">"];
                };
            IF plist[nameBody].Length[] # 0 THEN name _ name.Cat[plist[nameBody]];
            IF plist[version].Length[] # 0 THEN
                name _ name.Cat[IF type = alto THEN "!" ELSE ";", plist[version]];
            };

        MakeRemoteName: PUBLIC PROC [plist: PList, type: FilenameType] RETURNS [Rope.ROPE] = {
            RETURN[IF plist[serverName].Length[] = 0 THEN PListToName[plist, type]
                ELSE plist[serverName] ]};

        PutPListItem: PUBLIC PROC [byteStream: IO.STREAM, property: STPOps.ValidProperties, value: Rope.ROPE] = {
            byteStream.PutChar['(];
            MyPutString[byteStream, PropertyString[property]];
            byteStream.PutChar[' ];
            MyPutStringVal[byteStream, value];
            byteStream.PutChar[')];
            };

        ResetPList: PUBLIC PROC [plist: PList] = {
            IF plist # NIL THEN plist^ _ ALL[NIL] };

        GetFileInfo: PUBLIC PROC [stp: STPOps.Handle] RETURNS [STP.FileInfo] = {
            FOR i: STPOps.FileProperties IN STPOps.FileProperties DO
                SELECT i FROM
                    directory => stp.info.directory _ stp.plist[i];
                    nameBody => stp.info.body _ stp.plist[i];
                    version => stp.info.version _ stp.plist[i];
                    author => stp.info.author _ stp.plist[i];
                    createDate => stp.info.create _ stp.plist[i];
                    readDate => stp.info.read _ stp.plist[i];
                    writeDate => stp.info.write _ stp.plist[i];
                    size =>
                        stp.info.size _
                            IF stp.plist[i].Length[] = 0 THEN 0
                            ELSE Convert.IntFromRope[stp.plist[i]];
                    type => stp.info.type _ StringToFileType[stp.plist[i]];
                    ENDCASE;
                ENDLOOP;
            RETURN[stp.info];
            };

        SetPListItem: PUBLIC PROC [plist: PList, property, value: Rope.ROPE] = {
            FOR i: STPOps.ValidProperties IN STPOps.ValidProperties DO
                IF property.Equal[PropertyString[i], FALSE] THEN { plist[i] _ value; RETURN};
                ENDLOOP;
            ERROR BadProperty
            };

        UserStateToPList: PUBLIC PROC [stp: STPOps.Handle] = {
            FOR i: STPOps.UserProperties IN STPOps.UserProperties DO
                stp.plist[i] _ stp.userState[i];
                ENDLOOP;
            };

        <<Desired Property stuff>>

        SetDesiredProperties: PUBLIC PROC[stp: STPOps.Handle, props: STP.DesiredProperties] = {
            stp.desiredProps _ props
            };

        GetDesiredProperties: PUBLIC PROC [stp: STPOps.Handle] RETURNS [props: STP.DesiredProperties] = {
            RETURN[stp.desiredProps]
            };

        PutDesiredProps: PUBLIC PROC [stp: STPOps.Handle] = {
            FOR i: STPOps.FileProperties IN STPOps.FileProperties DO
                IF stp.desiredProps[i] THEN
                    PutDesiredPropsItem[stp.byteStream, PropertyString[i]]
                    ENDLOOP;
            };

        PutDesiredPropsItem: PUBLIC PROC [byteStream: IO.STREAM, value: Rope.ROPE] = {
            byteStream.PutChar['(];
            MyPutString[byteStream, desiredPropString];
            byteStream.PutChar[' ];
            MyPutString[byteStream, value];
            byteStream.PutChar[')];
            };

        }. -- of STPsD