-- File: FTPUserRetrieve.mesa, Edit:
  -- MAS Apr 16, 1980 2:33 PM  
  -- HGM July 31, 1980  5:38 PM  

-- Copyright  Xerox Corporation 1979, 1980

DIRECTORY
  FTPDefs,
  FTPPrivateDefs,
  String USING [EquivalentString],
  Storage USING [Node, Free];

FTPUserRetrieve: PROGRAM
  IMPORTS String, Storage, FTPDefs, FTPPrivateDefs
  EXPORTS FTPDefs
  SHARES FTPDefs =
BEGIN OPEN FTPDefs, FTPPrivateDefs;


FTPRetrieveFile: PUBLIC PROCEDURE [ftpuser: FTPUser, localFile, remoteFile: STRING, fileType: FileType] RETURNS [byteCount: 
LONG INTEGER] =
  BEGIN OPEN ftpuser;
  -- local constants
    nextFile: STRING = propertyList[serverFilename];
    bufferSize: CARDINAL = maximumDumpBlockSize+minimumDumpBlockSize;
  -- local variables
    retrieveState: {inactive, initiated, waiting, transferring, finishing} _ inactive;
    mark, code: Byte;
    fileHandle: FileHandle _ NIL;
    fileInfoObject: FileInfoObject _ [
      fileType: fileType, byteSize: 0, byteCount: 0,
      creationDate: NIL, writeDate: NIL, readDate: NIL,
      author: NIL];
    dumpStateObject: DumpStateObject _ [
      bufferAddress: NIL, bufferLength: 0, ftper: ftper, blockType: 0];
  -- verify purpose and state
    VerifyPurposeAndState[ftpuser, files, SELECT state FROM
      connected, enumeratingFiles => state,
      ENDCASE                      => inventoryingDumpFile];
  -- intercept errors
    BEGIN ENABLE UNWIND =>
      BEGIN ENABLE FTPError => IF ftpError IN CommunicationError THEN CONTINUE;
      IF dumpStateObject.bufferAddress # NIL THEN
        BEGIN
        nextBlockType _ dumpStateObject.blockType;
        Storage.Free[dumpStateObject.bufferAddress];
        END;
      IF fileHandle # NIL THEN filePrimitives.CloseFile[ftpuser.fileSystem, fileHandle, TRUE];
      IF retrieveState = transferring THEN
        BEGIN
        SELECT GetCommand[ftper].mark FROM
          markYes => NULL;
          markNo => GetEOC[ftper];
          ENDCASE => Abort[illegalProtocolSequence];
        IF state = connected THEN FinishMultiFileOperation[ftpuser];
        END;
-- What if loading?
      IF retrieveState = initiated THEN FinishMultiFileOperation[ftpuser];
      END;
  -- initiate remote retrieve
    IF state = connected THEN
      BEGIN
      -- send retrieve command
        PutCommand[ftper, markRetrieve, 0];
      -- construct property list containing absolute and virtual filenames, credentials, and file information
        ResetPropertyList[propertyList];
        WriteFilename[remoteFile, propertyList, NIL, NIL, primaryPropertyList];
        WriteFileInfo[propertyList, @fileInfoObject];
      -- send property list and EOC
        PutPropertyList[ftper, propertyList];  PutEOC[ftper];
      -- note retrieve initiated
        retrieveState _ initiated;
      END
  -- verify enumeration or inventory intent and filename
    ELSE
      BEGIN
      IF intent # retrieval THEN Abort[illegalProcedureCallSequence];
      IF nextFile = NIL OR ~String.EquivalentString[remoteFile, nextFile] THEN
        Abort[filenameUnexpected];
      WriteProperty[propertyList, serverFilename, NIL];
      END;
  -- sustain remote retrieve
    IF state = connected THEN
      BEGIN
      -- note waiting to transfer
        retrieveState _ waiting;
      -- receive property list and EOC
        [mark, code] _ GetCommand[ftper];
        SELECT mark FROM
          markHereIsPropertyList =>
            BEGIN
            GetPropertyList[ftper, propertyList];
            GetEOC[ftper];
            END;
          markNo =>
            BEGIN
            GetEOC[ftper];
            AbortWithExplanation[CodeToSignal[code], ftper.inputString];
            END;
          markEndOfCommand => AbortWithExplanation[noSuchFile, ftper.inputString];
          ENDCASE => Abort[illegalProtocolSequence];
      END;
  -- setup info for OpenFile
    ReadFileInfo[propertyList,@fileInfoObject];
  -- Open local file
    [fileHandle, ] _ filePrimitives.OpenFile[ftpuser.fileSystem, localFile, write, FALSE, @fileInfoObject];
  -- accept the offered file
    IF state # inventoryingDumpFile THEN
      BEGIN
      -- request the file and await acknowledgment
        PutCommandAndEOC[ftper, markYes, 0];
        [mark, code] _ GetCommand[ftper];
        SELECT mark FROM
          markHereIsFile => NULL;
          markNo =>
            BEGIN
            AbortWithExplanation[CodeToSignal[code], ftper.inputString];
            END;
          ENDCASE => Abort[illegalProtocolSequence];
      -- note transfer in progress
        retrieveState _ transferring;
      END;
  -- retrieve the file
    byteCount _ ftper.totalByteCount;
    IF state # inventoryingDumpFile THEN
      filePrimitives.WriteFile[ftpuser.fileSystem, fileHandle, ReceiveBlock, ftper]
    ELSE
      BEGIN
      -- allocate a buffer
        dumpStateObject.bufferAddress _ Storage.Node[bufferSize];
      -- receive the file
        filePrimitives.WriteFile[ftpuser.fileSystem, fileHandle, LoadBlock, @dumpStateObject];
        nextBlockType _ dumpStateObject.blockType;
      -- release the buffer
        Storage.Free[dumpStateObject.bufferAddress];
          dumpStateObject.bufferAddress _ NIL;
      END;
    byteCount _ ftper.totalByteCount - byteCount;
  -- terminate remote retrieve
    retrieveState _ finishing;
    IF state # inventoryingDumpFile THEN GetSpecificCommand[ftper, markYes];
    IF state = connected THEN FinishMultiFileOperation[ftpuser];
  -- close local file
    END; -- enable
    filePrimitives.CloseFile[ftpuser.fileSystem, fileHandle, FALSE];
  END;


END. -- of FTPUserRetrieve