--SrvrTn.mesa
--Server telnet with old style stream hooks
--Copies output to display
--LStewart September 19, 1978  10:52 AM

DIRECTORY
  IODefs: FROM "IODefs",
  ProcessDefs: FROM "ProcessDefs" USING [Detach,SetTimeout,MsecToTicks],
  PupStream: FROM "PupStream",
  SrvrTnDefs: FROM "SrvrTnDefs",
  Stream: FROM "Stream",
  StreamDefs: FROM "StreamDefs";

SrvrTn: MONITOR
  IMPORTS IODefs, PupStream, Stream, ProcessDefs
  EXPORTS SrvrTnDefs
  SHARES StreamDefs =

BEGIN OPEN IODefs, Stream, StreamDefs;

listener: PupStream.PupListener _ NIL;
socNum: PupStream.PupSocketID _ [0,1];  --telnet socket
herald: STRING _ "Mesa Server Telnet";
myStream: Stream.Handle;
closed: BOOLEAN _ TRUE;
echoLF: BOOLEAN _ TRUE;
chars: BOOLEAN _ FALSE;
open,sender: CONDITION;
timeLastSent: INTEGER;
clock: POINTER TO INTEGER = LOOPHOLE[430B];
keyStream, displayStream: StreamHandle;

myStreamObject: StreamObject _
  [
  reset: Reset,
  get: Get,
  putback: PutBack,
  put: Put,
  endof: Endof,
  destroy: Destroy,
  body: Other[]
  ];

Reset: PROCEDURE[os: StreamHandle] =
  BEGIN
  NULL;
  END;

Get: PROCEDURE[os: StreamHandle] RETURNS [UNSPECIFIED] =
  BEGIN
  eatByte: BOOLEAN;
  c: UNSPECIFIED;
    BEGIN
    ENABLE BEGIN
    SSTChange =>
      BEGIN
      IF sst=5 THEN  --WARNING!  This is dangerous!!
        BEGIN
        SetSST[myStream,6];
        SendNow[myStream];
        END;
      IF sst IN [2..4] THEN eatByte _ TRUE;
      RESUME;
      END;
    PupStream.StreamClosing =>
      BEGIN
      closed _ TRUE;
      WaitForOpen[];
      RETRY;
      END;
    Stream.TimeOut => RESUME;
    END;
    WaitForOpen[];
    eatByte _ TRUE;
    WHILE eatByte DO
      eatByte _ FALSE;
      c _ GetByte[myStream];
      ENDLOOP;
    RETURN[c];
    END;
  END;

PutBack: PROCEDURE[os: StreamHandle, thing: UNSPECIFIED] =
  BEGIN
  NULL;
  END;

Put: PROCEDURE[os: StreamHandle, thing: UNSPECIFIED] =
  BEGIN ENABLE PupStream.StreamClosing =>
    BEGIN
    closed _ TRUE;
    WaitForOpen[];
    RETRY;
    END;
  c: CHARACTER;
  displayStream.put[displayStream,thing];
  WaitForOpen[];
  PutByte[myStream,thing];
  chars _ TRUE;
  c _ thing;
  IF c=CR AND echoLF THEN PutByte[myStream,LOOPHOLE[LF]];
  IF c=CR THEN MySendNow[];
  END;

Endof: PROCEDURE[os: StreamHandle] RETURNS [BOOLEAN] =
  BEGIN
  RETURN[closed];
  END;

Destroy: ENTRY PROCEDURE[os: StreamHandle] =
  BEGIN
  myStream.delete[myStream];
  END;

MySendNow: ENTRY PROCEDURE =
  BEGIN
  Sendit[];
  END;

Sendit: INTERNAL PROCEDURE =
  BEGIN
  SendNow[myStream];
  chars _ FALSE;
  timeLastSent _ clock^;
  END;

SendOccasionally: ENTRY PROCEDURE =
  BEGIN
  WHILE NOT closed DO
    WAIT sender;
    IF chars AND (clock^-timeLastSent)>50 THEN Sendit[];
    ENDLOOP;
  END;

WaitForOpen: ENTRY PROCEDURE =
  BEGIN
  WHILE closed DO WAIT open ENDLOOP;
  END;

ServerStart: ENTRY PROCEDURE [bs: Handle, remote: PupStream.PupAddress] =
  BEGIN
  i: CARDINAL;
  eatByte: BOOLEAN _ FALSE;
  -- Mainline of server
  IF closed THEN
    BEGIN ENABLE PupStream.StreamClosing => GOTO Closeit;
    FOR i IN [0..herald.length)
      DO
      PutByte[bs,LOOPHOLE[herald.text[i]]];
      ENDLOOP;
    PutByte[bs,LOOPHOLE[CR]];
    IF echoLF THEN PutByte[bs,LOOPHOLE[LF]];
    SendNow[bs];
    myStream _ bs;
    closed _ FALSE;
    ProcessDefs.Detach[FORK SendOccasionally];
    BROADCAST open;
    END;
  EXITS
    Closeit =>
      BEGIN
      bs.delete[bs];
      closed _ TRUE;
      END;
  END;

StartServerTelnet: PUBLIC PROCEDURE =
  BEGIN
  WriteLine["Starting Server Telnet"];
  listener _ PupStream.CreatePupByteStreamListener [socNum, ServerStart, PupStream.SecondsToTocks[3]];
  ProcessDefs.SetTimeout[@open,ProcessDefs.MsecToTicks[1000]];
  ProcessDefs.SetTimeout[@sender,ProcessDefs.MsecToTicks[1000]];
  keyStream _ IODefs.GetInputStream[];
  displayStream _ IODefs.GetOutputStream[];
  IODefs.SetInputStream[@myStreamObject];
  IODefs.SetOutputStream[@myStreamObject];
  END;

  END.(1792)\357b6B659b5B56b3B175b33B248t2 1t0 10t2 1t0 199b7B76b3B151t2 1t0 8t2 2t0 224b6B84b7B83b9B48b6B102b16B145b11B73b11B518t2 1t0 97b17B