-- Copyright (C) 1983, 1985  by Xerox Corporation. All rights reserved. 
-- LineWatcher.mesa, HGM, 15-Nov-85  2:12:01

DIRECTORY
  Context USING [Create, Data, Find, Type, UniqueType],
  Display USING [Bitmap, Invert, replaceFlags, White],
  Exec USING [AddCommand, ExecProc, FreeTokenString, GetToken],
  Format USING [],  -- Needed by Put.Number
  FormSW USING [
    ClientItemsProcType, ProcType, AllocateItemDescriptor, newLine, CommandItem,
    StringItem, NumberItem],
  FileSW USING [GetFile, IsIt, SetFile],
  Heap USING [systemZone],
  MFile USING [Acquire, Error, GetLength, Handle, Release, SetTimes],
  MsgSW USING [Post],
  MStream USING [GetFile, GetLength, Handle, IsIt, Log, SetAccess, SetLength, SetLogReadLength],
  Process USING [Detach, MsecToTicks, Pause, Ticks],
  Put USING [Char, CR, Line, Number, Text],
  Runtime USING [GetBcdTime],
  Stream USING [GetByteProcedure, GetWordProcedure, GetProcedure, Handle],
  String USING [AppendLongNumber, AppendNumber, AppendString, Equivalent],
  System USING [
    AdjustGreenwichMeanTime, GreenwichMeanTime, GetGreenwichMeanTime, nullHostNumber],
  Time USING [Append, AppendCurrent, Unpack],
  Tool USING [
    Create, MakeSWsProc, UnusedLogName, MakeMsgSW, MakeFormSW, MakeFileSW,
    AddThisSW],
  ToolWindow USING [CreateSubwindow, DisplayProcType, nullBox, SetTinyName, TransitionProcType],
  Window USING [Handle, Box],

  Buffer USING [AccessHandle, DestroyPool, GetBuffer, MakePool, ReturnBuffer],
  EthernetDriverFriends USING [EtherStatsInfo],
  EthernetFormat USING [EtherStatsEntry, ethernetStatsReply, etherVersion],
  GateControlDefs USING [pupStatsAck, pupStatsNak, pupStatsSend],
  PhoneNetFriends USING [PhoneNetInfo],
  PhoneNetExtras USING [pupDupsFiltered, leafDupsFiltered, nsDupsFiltered],
  PupRouterDefs USING [GetRoutingTableEntry, maxHop, RoutingTableEntry],
  PupDefs USING [
    AppendPupAddress, PupPackageMake, PupPackageDestroy, PupBuffer,
    PupAddress, EnumeratePupAddresses,
    PupNameTrouble, SetPupContentsWords, PupSocket, PupSocketDestroy,
    PupSocketMake, MsToTocks],
  PupTypes USING [fillInSocketID, statSoc],
  PupWireFormat USING [BcplToMesaLongNumber],
  SlaFormat USING [LineState, RoutingTableEntry, SlaStatsEntry, slaStatsReply, slaVersion],
  Driver;

LineWatcher: MONITOR
  IMPORTS
    Context, Display, Exec, FileSW, FormSW, Heap, MFile, MsgSW, MStream, Process, Put,
    Runtime, String, System, Time, Tool, ToolWindow,
    Buffer, PupDefs, PupRouterDefs, PupWireFormat
  SHARES Driver =
  BEGIN

  contextType: PUBLIC Context.Type ¬ Context.UniqueType[];

  Data: TYPE = LONG POINTER TO DataRecord;
  DataRecord: TYPE = RECORD [
    tool, msg, form, boxes, log: Window.Handle ¬ NIL,
    running: BOOLEAN ¬ FALSE,
    pleaseStop: BOOLEAN ¬ FALSE,
    indicator: {left, right, off} ¬ off,
    seconds: CARDINAL ¬ 300,
    target: LONG STRING ¬ Heap.systemZone.NEW[StringBody[30]],
    netNumber: CARDINAL ¬ 0,
    where: PupDefs.PupAddress ¬ [[0], [0], PupTypes.statSoc],
    pool: Buffer.AccessHandle ¬ NIL,
    soc: PupDefs.PupSocket ¬ NIL,
    oldInfo: LONG POINTER TO LineInfo ¬ Heap.systemZone.NEW[LineInfo],
    newInfo: LONG POINTER TO LineInfo ¬ Heap.systemZone.NEW[LineInfo],
    new: BOOL ¬ FALSE, -- Old GateStats ignores new querrys
    cyclesPerSecond: LONG CARDINAL ¬ 0,
    thisID: CARDINAL ¬ 0 ];
  
  overheadPerPacket: CARDINAL = 4; -- Flag, CRC, CRC, flag
  -- Arg. Can't distinguish 3MB nets from 10MB nets
  ethernetOneOverheadPerPacket: CARDINAL = 2; -- CRC, CRC (and 1 preamble bit)
  ethernetOverheadPerPacket: CARDINAL = 8 + 4 + 12; -- preamble, CRC, gap (9.6 microseconds)

  Start: FormSW.ProcType =
    BEGIN
    data: Data = Context.Find[contextType, sw];
    oldLogFileName: LONG STRING ¬ FileSW.GetFile[data.log].name;
    newLogFileName: STRING = [100];
    netNumberString: STRING = [10];
    IF data.running THEN { MsgSW.Post[data.msg, "Somebody is already running..."L]; RETURN; };
    String.AppendNumber[netNumberString, data.netNumber, 8];
    String.AppendString[newLogFileName, data.target];
    String.AppendString[newLogFileName, "-"L];
    String.AppendString[newLogFileName, netNumberString];
    String.AppendString[newLogFileName, ".data"L];
    ToolWindow.SetTinyName[data.tool, data.target, netNumberString];
    IF ~String.Equivalent[oldLogFileName, newLogFileName] THEN
      BEGIN -- All this to get append mode. Yetch.
      fh: MFile.Handle ¬ NIL;
      bytes: LONG CARDINAL ¬ 0;
      sh: MStream.Handle;
      fh ¬ MFile.Acquire[newLogFileName, anchor, [] ! MFile.Error => CONTINUE];
      IF fh # NIL THEN {
        bytes ¬ MFile.GetLength[fh];
        MFile.Release[fh]; };
      sh ¬ MStream.Log[newLogFileName, []];
      IF bytes # 0 THEN {
        getByte: Stream.GetByteProcedure = sh.getByte;
        getWord: Stream.GetWordProcedure = sh.getWord;
        get: Stream.GetProcedure = sh.get;
        MStream.SetAccess[sh, writeOnly];
        MStream.SetLength[sh, bytes];
        MStream.SetAccess[sh, log];
        sh.getByte ¬ getByte;
        sh.getWord ¬ getWord;
        sh.get ¬ get; };
      FileSW.SetFile[data.log, newLogFileName, sh];
      IF fh = NIL THEN Put.Line[data.log, -- New File: Insert header for ChartPlot (and people)
"
*                                   Packets             Bytes      Bits/Sec     Errors
Date       Time      Sec  CPU P-Sent P-Recv   B-Sent   B-Recv   Sent   Recv  Dup Cong Miss  CRC
"L];
      END;
    Put.CR[data.log];
    Put.Text[data.log, "*  Watching net "L];
    O[data.log, data.netNumber];
    Put.Text[data.log, " on "L];
    IF ~FindPath[data] THEN RETURN;
    data.running ¬ TRUE;
    Process.Detach[FORK Watch[data, data.seconds]];
    END;

  Stop: FormSW.ProcType =
    BEGIN
    data: Data = Context.Find[contextType, sw];
    Off[data];
    END;

  Off: PROCEDURE [data: Data] =
    BEGIN
    IF ~data.running THEN RETURN;
    data.pleaseStop ¬ TRUE;
    WHILE data.running DO Process.Pause[1]; ENDLOOP;
    data.pleaseStop ¬ FALSE;
    END;

  FindPath: PROCEDURE [data: Data] RETURNS [BOOLEAN] =
    BEGIN
    Put.Text[data.log, data.target];
    Put.Char[data.log, '=];
    MyGetPupAddress[
      @data.where, data.target !
      PupDefs.PupNameTrouble =>
        BEGIN MsgSW.Post[data.msg, e]; Put.Line[data.log, e]; GOTO Trouble; END];
    PrintPupAddress[data.log, data.where];
    Put.Line[data.log, "."L];
    RETURN[TRUE];
    EXITS Trouble => RETURN[FALSE];
    END;

  MyGetPupAddress: PROCEDURE [
    him: LONG POINTER TO PupDefs.PupAddress, name: LONG STRING] =
    BEGIN
    SkipFlakeyNets: PROCEDURE [her: PupDefs.PupAddress] RETURNS [BOOLEAN] =
      BEGIN
      rte: PupRouterDefs.RoutingTableEntry;
      IF FlakeyNet[her] THEN RETURN[FALSE];
      rte ¬ PupRouterDefs.GetRoutingTableEntry[her.net];
      IF rte = NIL OR rte.context = NIL OR rte.hop > PupRouterDefs.maxHop THEN
        RETURN[FALSE];
      him.net ¬ her.net;
      him.host ¬ her.host;
      IF her.socket # [0, 0] THEN him.socket ¬ her.socket;
      RETURN[TRUE];
      END;
    IF PupDefs.EnumeratePupAddresses[name, SkipFlakeyNets] THEN RETURN;
    ERROR PupDefs.PupNameTrouble["No Route to that Host"L, noRoute];
    END;

  FlakeyNet: PROCEDURE [him: PupDefs.PupAddress] RETURNS [BOOLEAN] =
    BEGIN
    IF him.net > 277B THEN RETURN[TRUE];
    IF him.net = 106B THEN RETURN[TRUE]; -- Aylesbury/Welwyn-Link
    IF him.net = 141B THEN RETURN[TRUE]; -- CP10/DLOS-Link
    IF him.net = 202B THEN RETURN[TRUE]; -- FortXerox/CP10-Link
    RETURN[FALSE];
    END;

  Watch: PROCEDURE [data: Data, seconds: CARDINAL] =
    BEGIN
    startTime, stopTime, targetTime: System.GreenwichMeanTime;
    actual: LONG CARDINAL;
    pause: Process.Ticks;
    MakeConnection[data];
    SetupBoxes[data];
    pause ¬ Process.MsecToTicks[500];
    UNTIL data.pleaseStop DO -- Wait until even multiple of seconds
      targetTime ¬ System.GetGreenwichMeanTime[];
      IF (targetTime MOD seconds) = 0 THEN EXIT;
      Process.Pause[pause];
      ENDLOOP;
    startTime ¬ targetTime;
    GetInfo[data];
    data.oldInfo­ ¬ data.newInfo­;
    Put.CR[data.log];
    UNTIL data.pleaseStop DO
      WHILE System.GetGreenwichMeanTime[] - targetTime >= data.seconds DO
        IF targetTime > System.GetGreenwichMeanTime[] THEN EXIT;  -- Clock set backwards ==> hang
        -- Oops, it took us more than a cycle to process everything.
        -- Maybe we were sitting in the debugger.
        targetTime ¬ System.AdjustGreenwichMeanTime[targetTime, data.seconds];
        ENDLOOP;
      UNTIL data.pleaseStop OR (System.GetGreenwichMeanTime[] - targetTime) >= data.seconds DO
        Process.Pause[pause];
        ENDLOOP;
      IF data.pleaseStop THEN EXIT;
      GetInfo[data];
      stopTime ¬ System.GetGreenwichMeanTime[];
      actual ¬ stopTime - startTime;
      IF data.pleaseStop THEN EXIT;
      PrintInfo[data, actual];
      data.oldInfo­ ¬ data.newInfo­;
      startTime ¬ stopTime;
      targetTime ¬ System.AdjustGreenwichMeanTime[targetTime, seconds];
      ENDLOOP;
    SetDownBoxes[data];
    KillConnection[data];
    data.running ¬ FALSE;
    END;

  Cpu: TYPE = RECORD [cycles, cyclesPerSecond: LONG CARDINAL];
  State: TYPE = {down, up, looped, unknown};
  LineInfo: TYPE = RECORD [
    cycles: LONG CARDINAL,
    packetsSent: LONG CARDINAL,
    packetsRecv: LONG CARDINAL,
    bytesSent: LONG CARDINAL,
    bytesRecv: LONG CARDINAL,
    filtered: LONG CARDINAL,
    congestion: LONG CARDINAL,
    missed: LONG CARDINAL,
    badCrc: LONG CARDINAL,
    state: State];

  GetInfo: PROCEDURE [data:Data] =
    BEGIN
    b: PupDefs.PupBuffer;
    try: CARDINAL ¬ 0;
    data.thisID ¬ data.thisID + 1;
    DO  -- until we get the answer
      b ¬ Buffer.GetBuffer[pup, data.pool, send];
      b.pup.pupID ¬ [data.thisID, data.thisID];
      b.pup.pupType ¬ GateControlDefs.pupStatsSend;
      b.pup.pupWords[0] ¬ data.netNumber;
      b.pup.pupWords[1] ¬ 1;
      PupDefs.SetPupContentsWords[b, 2];
      IF ~data.new AND try > 10 THEN PupDefs.SetPupContentsWords[b, 1];
      data.soc.put[b];
      FlipBoxes[data];
      try ¬ try + 1;
      DO
        b ¬ data.soc.get[];
        IF b = NIL THEN EXIT;
        IF b.pup.pupType = error OR b.pup.pupType = GateControlDefs.pupStatsNak
          OR b.pup.pupID.b # data.thisID THEN BEGIN Buffer.ReturnBuffer[b]; LOOP; END;
        IF b.pup.pupType # GateControlDefs.pupStatsAck THEN ERROR;
	SELECT b.pup.pupWords[0] FROM
        SlaFormat.slaStatsReply => {
          SELECT b.pup.pupWords[1] FROM
	    SlaFormat.slaVersion => CopySlaData[data, b];
	    SlaFormat.slaVersion+1 => CopyPhoneData[data, b];
	    ENDCASE => ERROR;
          EXIT; };
        EthernetFormat.ethernetStatsReply => {
          SELECT b.pup.pupWords[1] FROM
            EthernetFormat.etherVersion => CopyOldEtherData[data, b];
            EthernetFormat.etherVersion+1 => CopyNewEtherData[data, b];
	    ENDCASE => ERROR;
          EXIT; };
        ENDCASE => ERROR;
	ENDLOOP;
      IF b # NIL THEN EXIT;
      IF data.pleaseStop THEN RETURN;
      LOOP;
      ENDLOOP;
    FlipBoxes[data];
    Buffer.ReturnBuffer[b];
    END;

  CopyPhoneData: PROCEDURE [data: Data, b: PupDefs.PupBuffer] =
    BEGIN
    cpu: LONG POINTER TO Cpu ¬ LOOPHOLE[@b.pup.pupWords[2]];
    psi: LONG POINTER TO PhoneNetFriends.PhoneNetInfo ¬ LOOPHOLE[cpu + SIZE[Cpu]];
    state: State;
    data.new ¬ TRUE;
    data.cyclesPerSecond ¬ cpu.cyclesPerSecond;
    SELECT psi.remoteHostNumber FROM
      System.nullHostNumber => state ¬ down;
      -- don't know his NS host number to check for looped
      ENDCASE => state ¬ up;
    data.newInfo­ ¬ [
      cycles: cpu.cycles,
      packetsSent: psi.stats[pktsSent],
      packetsRecv: psi.stats[pktsReceived],
      bytesSent: psi.stats[bytesSent],
      bytesRecv: psi.stats[bytesReceived],
      filtered:
        psi.stats[PhoneNetExtras.pupDupsFiltered] +
        psi.stats[PhoneNetExtras.leafDupsFiltered] +
        psi.stats[PhoneNetExtras.nsDupsFiltered],
      congestion: psi.stats[congestion] + psi.stats[connTooGreedy],
      missed: psi.stats[rcvErrorNoGet],
      badCrc: psi.stats[rcvErrorCRC],
      state: state ];
    END;

  CopySlaData: PROCEDURE [data: Data, b: PupDefs.PupBuffer] =
    BEGIN
    lastHost: CARDINAL ¬ b.pup.pupWords[2];
    rte: LONG POINTER TO SlaFormat.RoutingTableEntry ¬
      LOOPHOLE[@b.pup.pupWords[3] + lastHost*SIZE[SlaFormat.RoutingTableEntry]];
    sse: LONG POINTER TO SlaFormat.SlaStatsEntry ¬ LOOPHOLE[rte+1];
    state: State;
    SELECT sse.state FROM
      loopedBack => state ¬ looped;
      up => state ¬ up;
      down => state ¬ down;
      ENDCASE => state ¬ unknown;
    data.newInfo­ ¬ [
      cycles: 0,
      packetsSent: PupWireFormat.BcplToMesaLongNumber[sse.packetsSent],
      packetsRecv: PupWireFormat.BcplToMesaLongNumber[sse.packetsRecv],
      bytesSent: PupWireFormat.BcplToMesaLongNumber[sse.bytesSent],
      bytesRecv: PupWireFormat.BcplToMesaLongNumber[sse.bytesRecv],
      filtered: 0,
      congestion: 0,
      missed: sse.syncErrors,
      badCrc: sse.badCrc,
      state: state ];
    END;

  CopyNewEtherData: PROCEDURE [data: Data, b: PupDefs.PupBuffer] =
    BEGIN
    cpu: LONG POINTER TO Cpu ¬ LOOPHOLE[@b.pup.pupWords[2]];
    esi: LONG POINTER TO EthernetDriverFriends.EtherStatsInfo ¬ LOOPHOLE[cpu + SIZE[Cpu]];
    data.new ¬ TRUE;
    data.cyclesPerSecond ¬ cpu.cyclesPerSecond;
    data.newInfo­ ¬ [
      cycles: cpu.cycles,
      packetsSent: esi.packetsSent,
      packetsRecv: esi.packetsRecv,
      bytesSent: 2*esi.wordsSent,
      bytesRecv: 2*esi.wordsRecv,
      filtered: 0,
      congestion: 0,
      missed: esi.packetsMissed,
      badCrc: esi.badCrc + esi.crcAndBadAlignment,
      state: up ];
    END;

  CopyOldEtherData: PROCEDURE [data: Data, b: PupDefs.PupBuffer] =
    BEGIN
    ese: LONG POINTER TO EthernetFormat.EtherStatsEntry ¬ LOOPHOLE[@b.pup.pupWords[1]];
    data.newInfo­ ¬ [
      cycles: 0,
      packetsSent: PupWireFormat.BcplToMesaLongNumber[ese.packetsSent],
      packetsRecv: PupWireFormat.BcplToMesaLongNumber[ese.packetsRecv],
      bytesSent: 0,
      bytesRecv: 0,
      filtered: 0,
      congestion: 0,
      missed: PupWireFormat.BcplToMesaLongNumber[ese.inputOff],
      badCrc: PupWireFormat.BcplToMesaLongNumber[ese.badRecvStatus],
      state: up ];
    END;

  PrintInfo: PROCEDURE [data: Data, actual: LONG CARDINAL] =
    BEGIN
    restarted: BOOL ¬ FALSE;
    temp: LineInfo ¬ [
      cycles: data.newInfo.cycles - data.oldInfo.cycles,
      packetsSent: data.newInfo.packetsSent - data.oldInfo.packetsSent,
      packetsRecv: data.newInfo.packetsRecv - data.oldInfo.packetsRecv,
      bytesSent: data.newInfo.bytesSent - data.oldInfo.bytesSent,
      bytesRecv: data.newInfo.bytesRecv - data.oldInfo.bytesRecv,
      filtered: data.newInfo.filtered - data.oldInfo.filtered,
      congestion: data.newInfo.congestion - data.oldInfo.congestion,
      missed: data.newInfo.missed - data.oldInfo.missed,
      badCrc: data.newInfo.badCrc - data.oldInfo.badCrc,
      state: up ];
    PrintTime[data.log];
    Put.Text[data.log, " "L];
    IF LOOPHOLE[temp.packetsSent, LONG INTEGER] < 0 THEN { restarted ¬ TRUE; temp ¬ data.newInfo­; };
    LD5[data.log, actual];
    IF data.cyclesPerSecond = 0 THEN Put.Text[data.log, "    0"L]
    ELSE {
      used: LONG CARDINAL ¬ temp.cycles*100/data.cyclesPerSecond/actual;
      IF used > 100 THEN used ¬ 100;
      LD5[data.log, 100-used]; };
    LD7[data.log, temp.packetsSent];
    LD7[data.log, temp.packetsRecv];
    LD9[data.log, temp.bytesSent];
    LD9[data.log, temp.bytesRecv];
    LD7[data.log, (temp.bytesSent + overheadPerPacket*temp.packetsSent)*8/actual];
    LD7[data.log, (temp.bytesRecv + overheadPerPacket*temp.packetsRecv)*8/actual];
    IF (temp.filtered + temp.congestion + temp.missed + temp.badCrc) > 0 OR restarted THEN {
      LD5[data.log, temp.filtered];
      LD5[data.log, temp.congestion];
      LD5[data.log, temp.missed];
      LD5[data.log, temp.badCrc];
      IF restarted THEN Put.Text[data.log, " *R"L]; };
    Put.CR[data.log];
    ForceOutInfo[data.log];
    END;

  PrintTime: PROCEDURE [log: Window.Handle] =
    BEGIN
    text: STRING = [20];
    Time.AppendCurrent[text];
    Put.Text[log, text]
    END;

  PrintPupAddress: PROCEDURE [log: Window.Handle, a: PupDefs.PupAddress] =
    BEGIN
    text: STRING = [20];
    PupDefs.AppendPupAddress[text, a];
    Put.Text[log, text];
    END;

  O: PROCEDURE [log: Window.Handle, n: CARDINAL] =
    BEGIN
    Put.Number[log, n, [8, FALSE, TRUE, 0]];
    END;

  O2: PROCEDURE [log: Window.Handle, n: CARDINAL] =
    BEGIN
    Put.Char[log, ' ];
    Put.Number[log, n, [8, FALSE, TRUE, 1]];
    END;

  O3: PROCEDURE [log: Window.Handle, n: CARDINAL] =
    BEGIN
    Put.Char[log, ' ];
    Put.Number[log, n, [8, FALSE, TRUE, 2]];
    END;

  D: PROCEDURE [log: Window.Handle, n: CARDINAL] =
    BEGIN
    Put.Number[log, n, [10, FALSE, TRUE, 0]];
    END;

  D2: PROCEDURE [log: Window.Handle, n: CARDINAL] =
    BEGIN
    Put.Char[log, ' ];
    Put.Number[log, n, [10, FALSE, TRUE, 1]];
    END;

  D3: PROCEDURE [log: Window.Handle, n: CARDINAL] =
    BEGIN
    Put.Char[log, ' ];
    Put.Number[log, n, [10, FALSE, TRUE, 2]];
    END;

  D4: PROCEDURE [log: Window.Handle, n: CARDINAL] =
    BEGIN
    Put.Char[log, ' ];
    Put.Number[log, n, [10, FALSE, TRUE, 3]];
    END;

  LD2: PROCEDURE [log: Window.Handle, n: LONG INTEGER] =
    BEGIN
    s: STRING = [20];
    Put.Char[log, ' ];
    String.AppendLongNumber[s, n, 10];
    THROUGH [s.length..1) DO Put.Char[log, ' ]; ENDLOOP;
    Put.Text[log, s];
    END;

  LD3: PROCEDURE [log: Window.Handle, n: LONG INTEGER] =
    BEGIN
    s: STRING = [20];
    Put.Char[log, ' ];
    String.AppendLongNumber[s, n, 10];
    THROUGH [s.length..2) DO Put.Char[log, ' ]; ENDLOOP;
    Put.Text[log, s];
    END;

  LD5: PROCEDURE [log: Window.Handle, n: LONG INTEGER] =
    BEGIN
    s: STRING = [20];
    Put.Char[log, ' ];
    String.AppendLongNumber[s, n, 10];
    THROUGH [s.length..4) DO Put.Char[log, ' ]; ENDLOOP;
    Put.Text[log, s];
    END;

  LD7: PROCEDURE [log: Window.Handle, n: LONG INTEGER] =
    BEGIN
    s: STRING = [20];
    Put.Char[log, ' ];
    String.AppendLongNumber[s, n, 10];
    THROUGH [s.length..6) DO Put.Char[log, ' ]; ENDLOOP;
    Put.Text[log, s];
    END;

  LD9: PROCEDURE [log: Window.Handle, n: LONG INTEGER] =
    BEGIN
    s: STRING = [20];
    String.AppendLongNumber[s, n, 10];
    Put.Char[log, ' ];
    THROUGH [s.length..8) DO Put.Char[log, ' ]; ENDLOOP;
    Put.Text[log, s];
    END;

  MakeConnection: PROCEDURE [data: Data] =
    BEGIN
    data.pool ¬ Buffer.MakePool[send: 1, receive: 10];
    data.soc ¬ PupDefs.PupSocketMake[
      PupTypes.fillInSocketID, data.where, PupDefs.MsToTocks[5000]];
    END;

  KillConnection: PROCEDURE [data: Data] =
    BEGIN
    PupDefs.PupSocketDestroy[data.soc];
    Buffer.DestroyPool[data.pool];
    END;

  indicatorBox: Window.Box = [[25, 10], [16, 16]];
  DisplayBoxes: ToolWindow.DisplayProcType =
    BEGIN
    data: Data = Context.Find[contextType, window];
    pattern: ARRAY [0..1] OF ARRAY [0..8) OF WORD;
    left: WORD = 177400B;
    right: WORD = 000377B;
    SELECT data.indicator FROM
      left => pattern ¬ [ALL[left], ALL[right]];
      right => pattern ¬ [ALL[right], ALL[left]];
      off => pattern ¬ [ALL[0], ALL[0]];
      ENDCASE;
    Display.Bitmap[window, indicatorBox, [@pattern, 0, 0], 16, Display.replaceFlags]
    END;

  SetupBoxes: PROCEDURE [data: Data] =
    BEGIN
    data.indicator ¬ left;
    DisplayBoxes[data.boxes];
    END;

  FlipBoxes: PROCEDURE [data: Data] =
    BEGIN
    SELECT data.indicator FROM
      left => data.indicator ¬ right;
      off, right => data.indicator ¬ left;
      ENDCASE;
    Display.Invert[data.boxes, indicatorBox];
    END;

  SetDownBoxes: PROCEDURE [data: Data] =
    BEGIN
    data.indicator ¬ off;
    Display.White[data.boxes, indicatorBox];
    END;

  MakeBoxesSW: PROCEDURE [data: Data, window: Window.Handle] =
    BEGIN
    box: Window.Box ¬ ToolWindow.nullBox;
    box.dims.h ¬ 36;
    data.boxes ¬ ToolWindow.CreateSubwindow[
      parent: window,
      display: DisplayBoxes,
      box: box];
    Context.Create[type: contextType, data: data, proc: DropIt, window: data.boxes];
    Tool.AddThisSW[window: window, sw: data.boxes, swType: vanilla];
    END;

  MakeSWs: Tool.MakeSWsProc =
    BEGIN
    logFileName: STRING = [40];
    data: Data ¬ Context.Find[contextType, window];
    IF data = NIL THEN {
      data ¬ SIGNAL FindMyContext[];
      Context.Create[type: contextType, data: data, proc: DropIt, window: window]; };
    data.msg ¬ Tool.MakeMsgSW[window: window, lines: 5];
    BEGIN ENABLE FindMyContext => RESUME[data];
    data.form ¬ Tool.MakeFormSW[window: window, formProc: MakeForm];
    END;
    Context.Create[type: contextType, data: data, proc: DropIt, window: data.form];
    MakeBoxesSW[data, window];
    Tool.UnusedLogName[logFileName, "LineWatcher.log$"L];
    data.log ¬ Tool.MakeFileSW[window: window, name: logFileName, allowTypeIn: FALSE];
    END;

  MakeForm: FormSW.ClientItemsProcType =
    BEGIN
    nParams: CARDINAL = 5;
    data: Data = SIGNAL FindMyContext[];
    items ¬ FormSW.AllocateItemDescriptor[nParams];
    items[0] ¬ FormSW.CommandItem[
      tag: "Stop"L, proc: Stop, place: FormSW.newLine];
    items[1] ¬ FormSW.CommandItem[tag: "Start"L, proc: Start];
    items[2] ¬ FormSW.NumberItem[tag: "Seconds"L, value: @data.seconds, default: 60];
    items[3] ¬ FormSW.NumberItem[
      tag: "NetNumber"L, value: @data.netNumber, default: 7, radix: octal];
    items[4] ¬ FormSW.StringItem[tag: "Target"L, string: @data.target];
    RETURN[items, TRUE];
    END;

  ClientTransition: ToolWindow.TransitionProcType =
    BEGIN
    data: Data ¬ Context.Find[contextType, window];
    IF data = NIL THEN {
      data ¬ SIGNAL FindMyContext[];
      Context.Create[type: contextType, data: data, proc: DropIt, window: window]; };
    SELECT TRUE FROM
      old = inactive =>
        BEGIN
	IF data.target.length = 0 THEN String.AppendString[data.target, "ME"L];
	[] ¬ PupDefs.PupPackageMake[];
	END;
      new = inactive =>
        BEGIN IF data.running THEN Off[data]; PupDefs.PupPackageDestroy[]; END;
      ENDCASE;
    END;

  ForceOutInfo: ENTRY PROCEDURE [wh: Window.Handle] =
    -- Beware: This gets an SV lockup and then runs out of VM for Resident Memory
    BEGIN
    sh: Stream.Handle;
    IF ~FileSW.IsIt[wh] THEN RETURN;
    sh ¬ FileSW.GetFile[wh].s;
    IF ~MStream.IsIt[sh] THEN RETURN;
    Process.Pause[Process.MsecToTicks[5000]]; -- Let others play before we thrash
    MStream.SetLogReadLength[sh, MStream.GetLength[sh]];
    MFile.SetTimes[file: MStream.GetFile[sh], create: System.GetGreenwichMeanTime[]];
    END;

  FindMyContext: SIGNAL RETURNS [Data] = CODE;
  LineWatcherCommand: Exec.ExecProc =
    BEGIN
    tryIt: BOOLEAN ¬ FALSE;
    token: LONG STRING ¬ NIL;
    data: Data = Heap.systemZone.NEW[DataRecord ¬ []];
    herald: STRING = [100];
    String.AppendString[herald, "LineWatcher of  "L];
    Time.Append[herald, Time.Unpack[Runtime.GetBcdTime[]]];
    [token, ] ¬ h.GetToken[];
    IF token # NIL THEN {
      data.netNumber ¬ 0;
      FOR i: CARDINAL IN [0..token.length) DO
        c: CHAR = token[i];
	IF ~(c IN ['0..'7]) THEN EXIT;
	data.netNumber ¬ data.netNumber*10B + c-'0;
        ENDLOOP;
      token ¬ Exec.FreeTokenString[token]; };
    [token, ] ¬ h.GetToken[];
    IF token # NIL THEN {
      tryIt ¬ TRUE;
      String.AppendString[data.target, token];
      token ¬ Exec.FreeTokenString[token]; };
    BEGIN ENABLE FindMyContext => RESUME[data];
    data.tool ¬ Tool.Create[
      name: herald,
      cmSection: "LineWatcher"L,
      makeSWsProc: MakeSWs,
      clientTransition: ClientTransition];
    END;
    IF Context.Find[contextType, data.tool] = NIL THEN
      Context.Create[type: contextType, data: data, proc: DropIt, window: data.tool];
    IF tryIt THEN Start[data.form];
    END;

  DropIt: PROCEDURE [Data, Window.Handle] =
    BEGIN
    END;

  Exec.AddCommand["LineWatcher.~"L, LineWatcherCommand, NIL, NIL];

  END.