-- Copyright (C) 1982, 1984, 1985  by Xerox Corporation. All rights reserved. 
-- InitParms.mesa, HGM, 10-Mar-85  5:54:04
-- From OthelloFTP.mesa of 11-Dec-82 16:01:37

DIRECTORY
  Boot USING [EthernetBootFileNumber, Location],
  Device USING [Type],
  DeviceTypes USING [ethernet, ethernetOne],
  Environment USING [bytesPerPage, bytesPerWord],
  Format USING [HostNumber, StringProc],
  Heap USING [systemZone],
  HostNumbers USING [HostNumber],
  NSConstants USING [bootServerSocket],
  OthelloDefs USING [
    AbortingCommand, CheckUserAbort, CommandProcessor, GetName,
    IndexTooLarge, MyNameIs, Question, ReadShortNumber, RegisterCommandProc,
    WriteChar, WriteLine, WriteLongNumber, WriteOctal, WriteString, Yes],
  Process USING [Pause, SecondsToTicks],
  Space USING [ScratchMap, Unmap],
  STP USING [
    Close, Create, CreateRemoteStream, Enumerate, Error,
    ErrorCode, FileInfo, GetFileInfo, Handle, IsOpen, Login, NextFileName, 
    NoteFileProcType, Open, SetDirectory, SetHost],
  Stream USING [EndOfStream, Handle],
  String USING [AppendCharAndGrow, AppendString, CopyToNewString, Length],
  System USING [
    broadcastHostNumber, GreenwichMeanTime,
    NetworkAddress, nullNetworkNumber],
  Time USING [Append, Unpack],
  Unformat USING [Error, HostNumber],
  
  Indirect USING [GetParmFileName],
  OthelloForgot USING [],
  Parms USING [Error, GetBootLocation, GetMaxChars, GetParms, WriteBootLocation, WriteParms],
  PhoneFace USING [phoneLine];

InitParms: PROGRAM
  IMPORTS
    Format, Heap, OthelloDefs, Process, Space, STP, Stream, String, Time, Unformat,
    Indirect, Parms
  EXPORTS System, OthelloForgot =
  BEGIN
  
  HostNumber: PUBLIC TYPE = HostNumbers.HostNumber;

  host, userName, userPassword: LONG STRING ¬ NIL;
  directory, file: LONG STRING ¬ NIL;
  bootFileNumber: LONG STRING;
  
  --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  -- String/Credentials Commands
  --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  Directory: PROC = {
    OthelloDefs.MyNameIs[
      myNameIs: "Directory"L,
      myHelpIs: "Set Default FTP directory"L];
    OthelloDefs.GetName["Directory: "L, @directory]};

  GetUserNamePassword: PROC = {
    OthelloDefs.MyNameIs[
      myNameIs: "Login"L, myHelpIs: "Set user name-password"L];
    OthelloDefs.GetName["User: "L,     @userName];
    OthelloDefs.GetName["Password: "L, @userPassword, stars]};

  SmashPassword: PUBLIC PROCEDURE =
    BEGIN
    Heap.systemZone.FREE[@userName];
    Heap.systemZone.FREE[@userPassword]
    END;

  --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  -- Set BootLocation Command
  --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  SetBootLocation: PROC =
    BEGIN
    where: Boot.Location;
    OthelloDefs.MyNameIs[
      myNameIs: "Set Boot Location", myHelpIs: "Set Boot Location in EERom"L];
    SELECT TRUE FROM
      OthelloDefs.Yes["NS/10MB? "L] =>
        BEGIN
        bfn: HostNumber;
	board: CARDINAL ¬ 0;
        OthelloDefs.GetName["NS Boot File Number: "L, @bootFileNumber];
        GetAddress[@bfn, bootFileNumber !
          Unformat.Error => OthelloDefs.AbortingCommand["Can't parse that one (No CH)"L]];
        board ¬ OthelloDefs.ReadShortNumber[
          "Board: "L, 0, 3, board];
        where ¬ [
          deviceType: DeviceTypes.ethernet,
          deviceOrdinal: board,
	  vp: ethernet [ [
            bfn: [bfn],
            address: [
              net: System.nullNetworkNumber,
              host: System.broadcastHostNumber,
              socket: NSConstants.bootServerSocket] ]]];
        END;
      OthelloDefs.Yes["NS/Phone? "L] =>
        BEGIN
        bfn: HostNumber;
	line: CARDINAL ¬ 0;
        OthelloDefs.GetName["NS Boot File Number: "L, @bootFileNumber];
        GetAddress[@bfn, bootFileNumber !
          Unformat.Error => OthelloDefs.AbortingCommand["Can't parse that one (No CH)"L]];
        line ¬ OthelloDefs.ReadShortNumber[
          "Line: "L, 0, 3, line];
        where ¬ [
          deviceType: PhoneFace.phoneLine,
          deviceOrdinal: line,
	  vp: ethernet [ [
            bfn: [bfn],
            address: [
              net: System.nullNetworkNumber,
              host: System.broadcastHostNumber,
              socket: NSConstants.bootServerSocket] ]]];
        END;
      OthelloDefs.Yes["Pup/3MB? "L] =>
        BEGIN
        bfn: CARDINAL ¬ OthelloDefs.ReadShortNumber[
          "Pup Boot File Number: "L, 0, 177777B, 140000B];
	board: CARDINAL ¬ 0;
        board ¬ OthelloDefs.ReadShortNumber[
          "Board: "L, 0, 3, board];
        where ¬ [
          deviceType: DeviceTypes.ethernetOne,
          deviceOrdinal: board,
          vp: ethernetOne [
            bootFileNumber: bfn, net: 0, host: 0 ] ];
        END;
      ENDCASE => OthelloDefs.AbortingCommand["No other options implemented."L];
    Parms.WriteBootLocation[where ! Parms.Error =>
      BEGIN
      OthelloDefs.WriteString["Trouble Writing BootLocation: "L];
      OthelloDefs.WriteLine[reason];
      CONTINUE;
      END;];
    OthelloDefs.WriteLine["done"L];
    END;
    
  --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  -- Fetch Parm File Command
  --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  FetchParmFile: PROC =
    BEGIN
    GetString: PROC [s: LONG STRING] =
      BEGIN
      OthelloDefs.WriteString["storing..."L];
      Parms.WriteParms[s ! Parms.Error =>
        BEGIN
        OthelloDefs.WriteString["Trouble Writing Parms: "L];
        OthelloDefs.WriteLine[reason];
        CONTINUE;
        END;];
      END;
    OthelloDefs.MyNameIs[
      myNameIs: "Fetch Parm File", myHelpIs: "Fetch Parameter File from FileServer and store it in EERom"L];
    OthelloDefs.GetName["Parameter file: "L, @file
    ! OthelloDefs.Question => {
      OthelloDefs.WriteLine["Filename"L]; RESUME}];
    IF ~ConnectionOpen[] AND ~ReOpen[] THEN
      BEGIN
      IF host # NIL THEN Open[];
      IF ~ConnectionOpen[] THEN OthelloDefs.AbortingCommand["Please open a connection"L];
      END;
    Retrieve[destination: [string[GetString]]];
    OthelloDefs.WriteLine["done"L];
    END;
    
  --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  -- Type Parm File Command
  --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  TypeParmFile: PROC =
    BEGIN
    s: LONG STRING ¬ NIL;
    BEGIN ENABLE UNWIND => Heap.systemZone.FREE[@s];
    boot: Boot.Location;
    write: System.GreenwichMeanTime;
    goodBoot, goodParms: BOOLEAN ¬ TRUE;
    OthelloDefs.MyNameIs[
      myNameIs: "Type Parm File", myHelpIs: "Type Parameter File from EERom"L];
    s ¬ Heap.systemZone.NEW[StringBody[Parms.GetMaxChars[]]];
    [boot, write] ¬ Parms.GetBootLocation[ ! Parms.Error =>
      BEGIN
      OthelloDefs.WriteString["Can't read BootLocation: "L];
      OthelloDefs.WriteString[reason];
      OthelloDefs.WriteLine["."L];
      goodBoot ¬ FALSE;
      CONTINUE;
      END];
    IF goodBoot THEN
      BEGIN
      OthelloDefs.WriteString["Boot Location Written: "L];
      WriteTime[write];
      OthelloDefs.WriteLine["."L];
      OthelloDefs.WriteString["Boot Info: "L];
      SELECT boot.deviceType FROM
        DeviceTypes.ethernet =>
	  BEGIN
          OthelloDefs.WriteString["NS/10MB Boot File #"L];
	  WriteBFN[boot.ethernetRequest.bfn];
          OthelloDefs.WriteString[", Board: "L];
          OthelloDefs.WriteLongNumber[boot.deviceOrdinal];
	  END;
        PhoneFace.phoneLine =>
	  BEGIN
          OthelloDefs.WriteString["NS/Phone Boot File #"L];
	  WriteBFN[boot.ethernetRequest.bfn];
          OthelloDefs.WriteString[", Line: "L];
          OthelloDefs.WriteLongNumber[boot.deviceOrdinal];
	  END;
        DeviceTypes.ethernetOne =>
	  BEGIN
          OthelloDefs.WriteString["Pup/3MB Boot File #"L];
	  OthelloDefs.WriteOctal[boot.bootFileNumber];
          OthelloDefs.WriteString[", Board: "L];
          OthelloDefs.WriteLongNumber[boot.deviceOrdinal];
	  END;
	ENDCASE =>
	  BEGIN
          p: POINTER TO ARRAY [0..0) OF WORD = LOOPHOLE[@boot];
          FOR i: CARDINAL IN [0..SIZE[Boot.Location]) DO
            IF i # 0 THEN OthelloDefs.WriteString[", "L];
	    OthelloDefs.WriteOctal[p[i]];
            ENDLOOP;
	  END;
      OthelloDefs.WriteLine["."L];
      END;
    OthelloDefs.WriteLine[""L];
    [write] ¬ Parms.GetParms[s ! Parms.Error =>
      BEGIN
      OthelloDefs.WriteString["Can't read Parms: "L];
      OthelloDefs.WriteString[reason];
      OthelloDefs.WriteLine["."L];
      goodParms ¬ FALSE;
      CONTINUE;
      END];
    IF goodParms THEN
      BEGIN
      OthelloDefs.WriteString["Parms Written: "L];
      WriteTime[write];
      OthelloDefs.WriteLine["."L];
      OthelloDefs.WriteString["Text length: "L];
      OthelloDefs.WriteLongNumber[s.length];
      OthelloDefs.WriteString[".  (Max is "L];
      OthelloDefs.WriteLongNumber[Parms.GetMaxChars[]];
      OthelloDefs.WriteLine[".)"L];
      OthelloDefs.WriteLine[s];
      END;
    OthelloDefs.WriteLine[""L];
    Heap.systemZone.FREE[@s];
    END;
    END;
    
  --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  -- IO Routines
  --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  WriteTime: PROCEDURE [t: System.GreenwichMeanTime] =
    BEGIN
    temp: STRING = [40];
    Time.Append[temp, Time.Unpack[t], TRUE];
    OthelloDefs.WriteString[temp];
    END;

  WriteBFN: PROCEDURE [bfn: Boot.EthernetBootFileNumber] =
    BEGIN
    Append: Format.StringProc = BEGIN String.AppendString[temp, s]; END;
    temp: STRING = [40];
    Format.HostNumber[Append, bfn, octal];
    OthelloDefs.WriteString[temp];
    END;

  GetAddress: PROCEDURE [host: POINTER TO HostNumber, s: LONG STRING] =
    BEGIN
    host­ ¬ Unformat.HostNumber[s, octal];
    END;

  --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  -- MISC Stuff/Commands
  --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  userOpened: BOOLEAN ¬ FALSE;
  OpenCmd: PROC = {
    OthelloDefs.MyNameIs[myNameIs: "Open"L, myHelpIs: "STP Open"L];
    CloseCmd[];
    OthelloDefs.GetName["Open connection to "L, @host];
    Open[]; userOpened ¬ TRUE};

  ReOpen: PROC RETURNS [BOOLEAN] = {
    IF userOpened=FALSE THEN RETURN[FALSE];
    Open[]; RETURN[TRUE]};
    
  CloseCmd: PROC = {
    OthelloDefs.MyNameIs[myNameIs: "Close"L, myHelpIs: "STP Close"L];
    userOpened ¬ FALSE; Close[]};
    
  RemoteList: PROC = {
    OthelloDefs.MyNameIs[
      myNameIs: "List Remote Files"L, myHelpIs: "List Remote Files"L];
    IF ~ConnectionOpen[] AND ~ReOpen[] THEN
      OthelloDefs.AbortingCommand["Please open a connection"L];
    OthelloDefs.GetName["Pattern: "L, @file];
    IF String.Length[file] = 0 THEN
      String.AppendCharAndGrow[@file, '*, Heap.systemZone];
    ListFiles[]};

  --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  -- Central commands
  --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  commandProcessor: OthelloDefs.CommandProcessor ¬ [FtpCommands];

  FtpCommands: PROC [index: CARDINAL] = {
    SELECT index FROM
      0 => TypeParmFile[];
      1 => SetBootLocation[];
      2 => FetchParmFile[];
      3 => Directory[];
      4 => GetUserNamePassword[];
      5 => OpenCmd[];
      6 => CloseCmd[];
      7 => RemoteList[];
      ENDCASE => OthelloDefs.IndexTooLarge};


  --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  -- STP Stuff/Commands
  --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  stp: STP.Handle ¬ NIL;
  
  ConnectionOpen: PROC RETURNS [BOOLEAN] = {
    RETURN[stp # NIL AND STP.IsOpen[stp]]};
    
  -- all callers close the connection first
  Open: PROC = {
    herald: LONG STRING ¬ NIL;
    IF stp = NIL THEN stp ¬ STP.Create[];
    DO
      herald ¬ STP.Open[stp, host
      ! STP.Error => SELECT code FROM
          connectionTimedOut, connectionClosed, noRouteToNetwork,
          noNameLookupResponse, connectionRejected => {
	    OthelloDefs.WriteLine[error]; CONTINUE};
          ENDCASE => OthelloDefs.AbortingCommand[error]];
      IF herald # NIL THEN EXIT;
      Process.Pause[Process.SecondsToTicks[10]];
      OthelloDefs.CheckUserAbort[];
      ENDLOOP;
    OthelloDefs.WriteLine[herald];
    Heap.systemZone.FREE[@herald];
    STP.SetHost[stp, host]};
  
  Close: PROC = {
    IF ~ConnectionOpen[] THEN RETURN;
    STP.Close[stp ! STP.Error => OthelloDefs.AbortingCommand[error]];
    OthelloDefs.WriteLine["Connection closed"L]};
  
  -- could mess with directories.
  -- who cares
  ListFiles: PROC = {
    ListOne: STP.NoteFileProcType = {
      info: STP.FileInfo = STP.GetFileInfo[stp];
      OthelloDefs.WriteString[file];
      THROUGH [file.length..80-info.create.length) DO
        OthelloDefs.WriteChar[' ] ENDLOOP;
      OthelloDefs.WriteLine[info.create];
      --OthelloDefs.WriteChar[' ];
      --OthelloDefs.WriteLine[info.author];
      --OthelloDefs.WriteChar[' ];
      --OthelloDefs.WriteLongNumber[info.size];
      --OthelloDefs.WriteLine[" bytes]"L];
      OthelloDefs.CheckUserAbort[];
      RETURN[yes]};
    STP.Login[stp, userName, userPassword];
    STP.SetDirectory[stp, directory];
    STP.Enumerate[stp, file, ListOne
    ! STP.Error => OthelloDefs.AbortingCommand[error]]};

  Destination: TYPE = RECORD [
    SELECT type: * FROM
      string               => [stringProc: PROC [LONG STRING]],
      ENDCASE];
      
  StartFeedback: SIGNAL = CODE;
  Retrieve: PROC [destination: Destination] =
    BEGIN
    rs: Stream.Handle;
    Cleanup: PROC = BEGIN rs.delete[rs]; END;
    rs ¬ GetReadStream[! STP.Error => OthelloDefs.AbortingCommand[error]];
    IF rs=NIL THEN RETURN;
    GrabBits[rs, destination
    ! STP.Error => OthelloDefs.AbortingCommand[error];
      StartFeedback => {
        OthelloDefs.WriteString["Fetching..."L];
        RESUME};
      UNWIND => Cleanup[]; ];
    Cleanup[];
    END;
    
  GetReadStream: PROC RETURNS [rs: Stream.Handle] = {
    STP.Login[stp, userName, userPassword];
    STP.SetDirectory[stp, directory];
    rs ¬ STP.CreateRemoteStream[stp, file, read];
    rs.options.signalEndOfStream ¬ TRUE;
    DO 
      info: STP.FileInfo; s: LONG STRING;
      s ¬ STP.NextFileName[rs ! UNWIND => rs.delete[rs]];
      IF s = NIL THEN {rs.delete[rs]; RETURN[NIL]};
      info ¬ STP.GetFileInfo[stp ! UNWIND => rs.delete[rs]];
      OthelloDefs.WriteString[s]; Heap.systemZone.FREE[@s];
      OthelloDefs.WriteChar['[]; OthelloDefs.WriteString[info.create];
      OthelloDefs.WriteString[", bytes = "]; OthelloDefs.WriteLongNumber[info.size];
      OthelloDefs.WriteChar[']];
      IF OthelloDefs.Yes[" [Confirm]: "L ! UNWIND => rs.delete[rs]] THEN EXIT;
      ENDLOOP;
    RETURN};
    

  bufPages: CARDINAL     = 8;
  
  GrabBits: PROC [
    rs: Stream.Handle, destination: Destination] = {
    WITH destination SELECT FROM
      string => {
	SIGNAL StartFeedback;
	DO
          stringOverhead: CARDINAL = SIZE[StringBody]*Environment.bytesPerWord;
          string: LONG STRING = Space.ScratchMap[bufPages];
          string­ ¬ [
	    length: 0,
	    maxlength: bufPages*Environment.bytesPerPage - stringOverhead,
	    text: ];
	  WHILE string.length < string.maxlength DO
            got: CARDINAL;
	    [bytesTransferred: got] ¬ rs.get[
	      rs,
	      [blockPointer: LOOPHOLE[@string.text],
	       startIndex: string.length,
	       stopIndexPlusOne: string.maxlength],
	      rs.options
	      ! Stream.EndOfStream => {
	          got ¬ 0; string.length ¬ string.length + nextIndex; CONTINUE};
                UNWIND => [] ¬ Space.Unmap[string]];
	    IF got = 0 THEN {
	      stringProc[string! UNWIND => [] ¬ Space.Unmap[string]];
	      [] ¬ Space.Unmap[string]; RETURN};
            string.length ¬ string.length + got;
            ENDLOOP;
          [] ¬ Space.Unmap[string];
          OthelloDefs.AbortingCommand["Command file too long!"L];
          ENDLOOP};
      ENDCASE => ERROR};
      
  --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  -- initialization
  --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  bootFileNumber ¬ String.CopyToNewString["25200002000", Heap.systemZone];
  host ¬ String.CopyToNewString["Indigo", Heap.systemZone];
  directory ¬ String.CopyToNewString["Portola>Parameters", Heap.systemZone];
  file ¬ String.CopyToNewString[Indirect.GetParmFileName[], Heap.systemZone];
  OthelloDefs.RegisterCommandProc[@commandProcessor];
  END.....