DIRECTORY
Atom USING [GetPName],
BasicTime USING [
GetClockPulses, GMT, Now, Period, Pulses, PulsesToMicroseconds, Unpacked, Unpack],
Buttons USING [Button, ButtonProc, Create, SetDisplayStyle],
Commander USING [CommandProc, Register],
Containers USING [ChildXBound, ChildYBound, Create],
Convert USING [Error, IntFromRope, RopeFromInt],
ImagerFont USING [RopeEscapement],
IO USING [Flush, PutF, PutFR, PutRope, STREAM, Value],
Labels USING [Create],
Loader USING [BCDBuildTime],
PrincOps USING [zEXCH],
Real USING [Round],
Rope USING [ROPE],
Rules USING [Create],
TypeScript USING [ChangeLooks, Create],
ViewerClasses USING [Viewer],
ViewerIO USING [CreateViewerStreams],
ViewerOps USING [AddProp, ComputeColumn, CreateViewer, MoveViewer, OpenIcon, SetOpenHeight],
ViewerTools USING [GetContents, MakeNewTextViewer, SetContents, SetSelection],
VFonts USING [DefaultFont],
IPDefs USING [Byte, DataBuffer, Datagram, DatagramRec, DByte, Address, InternetHeader, nullAddress],
IPName USING [AddressToName, AddressToRope, LoadCacheFromName, NameToAddress],
ICMP USING [BodyRec, Create, Destroy, Echo, EchoReply, Handle, maxLength, minLength, Receive, Send, Timestamp, TimestampReply];

ICMPEchoTool: CEDAR MONITOR
IMPORTS
Atom, BasicTime, Buttons, Commander, Containers, Convert, ImagerFont, IO, Labels, Loader, Real, Rules, TypeScript, ViewerIO, ViewerOps, ViewerTools, IPName, ICMP, VFonts =
BEGIN

ROPE: TYPE = Rope.ROPE;
STREAM: TYPE = IO.STREAM;
Viewer: TYPE = ViewerClasses.Viewer;

buttonHeight: INTEGER = 16;
buttonWidth: INTEGER _ ButtonWidth["Target"];

ClientData: TYPE = REF ClientDataRep;
ClientDataRep: TYPE = RECORD [
log: STREAM _ NIL,
in: STREAM _ NIL,
pleaseStop: BOOLEAN _ FALSE,
user: PROCESS _ NIL,
where: IPDefs.Address _ IPDefs.nullAddress,
echo: REF BOOL _ NEW [BOOL _ TRUE],
miss: REF BOOL _ NEW [BOOL _ TRUE],
late: REF BOOL _ NEW [BOOL _ TRUE],
fixedLength: REF BOOL _ NEW [BOOL _ FALSE],
target, length, timeout, delay, pause: Viewer _ NIL,
good: INT _ 0,
minDelay, maxDelay: INT _ 0,
delayHist: ARRAY DelayRange OF INT _ ALL[0] ];

DelayRange: TYPE = {
d1, d1a, d2, d2a, d3, d3a, d4, d4a, d5, d5a, d6, d6a, d7, d7a, d8, d8a, d9, d9a, 
d10, d14, d20, d28, d50, d70, d100, d140, d200, d280, d500, d700,
d1000, d1400, d2000, d2800, d5000, d7000, d10000, d14000, d20000, d28000, d50000, more};

delayTime: ARRAY DelayRange OF INT = [
d1: 1000, d1a: 1500, d2: 2000, d2a: 2500,
d3: 3000, d3a: 3500, d4: 4000, d4a: 4500,
d5: 5000, d5a: 5500, d6: 6000, d6a: 6500,
d7: 7000, d7a: 7500, d8: 8000, d8a: 8500,
d9: 9000, d9a: 9500,
d10: 10000, d14: 14000, d20: 20000, d28: 28000, d50: 50000, d70: 70000,
d100: 100000, d140: 140000, d200: 200000, d280: 280000, d500: 500000, d700: 700000,
d1000: 1000000, d1400: 1400000, d2000: 2000000, d2800: 2800000, d5000: 5000000, d7000: 7000000,
d10000: 10000000, d14000: 14000000, d20000: 20000000, d28000: 28000000, d50000: 50000000, more: LAST[INT]];

Create: Commander.CommandProc = TRUSTED {
data: ClientData _ NEW[ClientDataRep _ []];
viewer, buttons, log: Viewer _ NIL;
viewer _ ViewerOps.CreateViewer [
flavor: $Container,
info: [name: "ICMP EchoTool", column: right, iconic: TRUE, scrollable: FALSE]]; 
ViewerOps.AddProp[viewer, $ICMPEcho, data];

log _ TypeScript.Create[
[name: "ICMPEchoTool.log", wy: 27+4, parent: viewer, border: FALSE], FALSE];
[data.in, data.log] _ ViewerIO.CreateViewerStreams [
name: "ICMPEchoTool.log", backingFile: "ICMPEchoTool.log", viewer: log, editedStream: FALSE];
Containers.ChildXBound[viewer, log];
Containers.ChildYBound[viewer, log];
CreateButtons[data, viewer, log];
TypeScript.ChangeLooks[log, 'f];
IO.PutF[data.log, "ICMP EchoTool of %G.\n", [time[Loader.BCDBuildTime[Create]]]];
ViewerOps.OpenIcon[viewer]; }; 

CreateButtons: ENTRY PROC[data: ClientData, parent, log: Viewer] = {
child: Viewer _ NIL;
kids: Viewer = Containers.Create[
info: [parent: parent, border: FALSE, scrollable: FALSE, wx: 0, wy: -9999, ww: 9999, wh: 0] ];
Containers.ChildXBound[parent, kids];
child _ MakeBool[name: "!", init: data.echo, clientData: data, parent: kids, sibling: child, x: 2, y: 1];
child _ MakeBool[name: "?", init: data.miss, clientData: data, parent: kids, sibling: child];
child _ MakeBool[name: "#", init: data.late, clientData: data, parent: kids, sibling: child];
child _ MakeBool[name: "FixedLength", init: data.fixedLength, clientData: data, parent: kids, sibling: child];
child _ data.length _ MakeLabeledText[
parent: kids,
sibling: child,
name: "Length:",
data: Convert.RopeFromInt[ICMP.maxLength],
prev: data.length,
newline: FALSE,
dataWidth: ButtonWidth["9999"] ];
child _ data.timeout _ MakeLabeledText[
parent: kids,
sibling: child,
name: "Timeout:",
data: Convert.RopeFromInt[5000],
prev: data.timeout,
newline: FALSE ];
child _ MakeRule[kids, child];
child _ data.target _ MakeLabeledText[
parent: kids,
sibling: child,
name: "Target:",
data: "
Target",
prev: data.target ];
child _ MakeRule[kids, child];
child _ MakeLabel[kids, child, "What:"];
child _ MakeButton[kids, child, data, "Time", TimeProc];
child _ MakeButton[kids, child, data, "Start", StartProc];
child _ MakeButton[kids, child, data, "Hist", HistProc];
child _ MakeButton[kids, child, data, "Stop", StopProc];
child _ MakeRule[kids, child];
{
kidsY: INTEGER = 2;
kidsH: INTEGER = child.wy + child.wh + 2;
ViewerOps.MoveViewer[viewer: log, x: 0, y: kidsY + kidsH, w: log.ww, h: parent.ch - (kids.wy + kidsH), paint: FALSE];
IF FALSE THEN ViewerOps.SetOpenHeight[parent, kidsY + kidsH + 12 * buttonHeight];
IF ~parent.iconic THEN ViewerOps.ComputeColumn[parent.column];
ViewerOps.MoveViewer[viewer: kids, x: kids.wx, y: kidsY, w: kids.ww, h: kidsH]; };
};

StartProc: Buttons.ButtonProc = {
data: ClientData _ NARROW[clientData];
Start[data]; };

Start: PROC [data: ClientData] = {
target: ROPE = ViewerTools.GetContents[data.target];
IF data.user # NIL THEN Stop[data];
Report[data, "\nEchoing to ", target, " "];
IF ~FindPath[data, target] THEN RETURN;
data.pleaseStop _ FALSE;
data.user _ FORK User[data]; };

HistProc: Buttons.ButtonProc = {
data: ClientData _ NARROW[clientData];
Stop[data];
PrintDelayHist[data]; };

StopProc: Buttons.ButtonProc = {
data: ClientData _ NARROW[clientData];
Stop[data]; };

Stop: PROC [data: ClientData] = TRUSTED {
data.pleaseStop _ TRUE;
IF data.user # NIL THEN JOIN data.user;
data.user _ NIL; };

User: PROC [data: ClientData] = TRUSTED {
start, finish: BasicTime.GMT;
sent, mashed, missed, late, bogus: INT _ 0;
bytes: INT _ 0;
packetNumber: CARDINAL _ 0;
fixedLength: BOOL = data.fixedLength^;
lengthText: ROPE = ViewerTools.GetContents[data.length];
minLength: CARDINAL _ ICMP.minLength;
maxLength: CARDINAL _ ICMP.maxLength;
lengthCard: CARDINAL _ ICMP.maxLength;
handle: ICMP.Handle _ ICMP.Create[him: data.where];
timeoutText: ROPE = ViewerTools.GetContents[data.timeout];
timeoutMin: CARDINAL _ 100;
timeoutMax: CARDINAL _ 60000;
timeout: INT;
timeout _ Convert.IntFromRope[timeoutText ! Convert.Error => {
IO.PutF[data.log, "Can't parse Timeout field.\n"];
timeout _ 0;
CONTINUE; } ];
timeout _ MAX[timeout, timeoutMin];
timeout _ MIN[timeout, timeoutMax];
IF fixedLength THEN {
temp: INT;
temp _ Convert.IntFromRope[lengthText ! Convert.Error => {
IO.PutF[data.log, "Can't parse Length field.\n"];
lengthCard _ 0;
CONTINUE; } ];
temp _ MAX[temp, minLength];
temp _ MIN[temp, maxLength];
lengthCard _ temp;
IO.PutF[data.log, "Packet length is %G bytes.\n", [integer[lengthCard]]]; };
InitDelayHist[data];
data.good _ 0;
start _ BasicTime.Now[];
UNTIL data.pleaseStop DO
FOR cycle: CARDINAL IN [minLength..maxLength] UNTIL data.pleaseStop DO
packetStart, packetStop: BasicTime.Pulses;
dg: IPDefs.Datagram _ NEW [IPDefs.DatagramRec];
length: CARDINAL _ IF fixedLength THEN lengthCard ELSE cycle;
body: LONG POINTER TO ICMP.BodyRec _ LOOPHOLE[@dg.data];
body.type _ ICMP.Echo;
body.sequenceNo _ (packetNumber _ packetNumber.SUCC);
FOR k: CARDINAL IN [minLength..length) DO
body.data[k] _ k MOD 100H; ENDLOOP;
packetStart _ BasicTime.GetClockPulses[];
ICMP.Send[handle, dg, length];
sent _ sent + 1;
UNTIL (dg _ ICMP.Receive[handle, timeout]) = NIL DO
body _ LOOPHOLE[@dg.data];
SELECT TRUE FROM
body.type # ICMP.EchoReply => {
bogus _ bogus + 1;
IO.PutF[data.log, "Wrong Type: %G.\n", [cardinal[body.type]] ]; };
(body.sequenceNo # packetNumber) OR (dg.dataLength # length) =>
BEGIN late _ late + 1; IF data.late^ THEN IO.PutRope[data.log, "#"]; END;
ENDCASE => {
packetStop _ BasicTime.GetClockPulses[];
AddToDelayHist[data, BasicTime.PulsesToMicroseconds[packetStop-packetStart]];
FOR k: CARDINAL IN [minLength..length) DO
IF body.data[k] # k MOD 100H THEN {
IO.PutRope[data.log, "~"];
mashed _ mashed + 1;
GOTO Evil; };
ENDLOOP;
IF data.echo^ THEN IO.PutRope[data.log, "!"];
data.good _ data.good + 1;
bytes _ bytes + length-minLength;
EXIT; };
dg _ NIL;
REPEAT Evil => NULL;
ENDLOOP;
IF dg # NIL THEN dg _ NIL
ELSE { missed _ missed + 1; IF data.miss^ THEN IO.PutRope[data.log, "?"]; };
ENDLOOP;
IF ~data.echo^ THEN IO.PutRope[data.log, "."] ELSE IO.PutRope[data.log, "\n"];
ENDLOOP;
IO.PutRope[data.log, "\n"];
finish _ BasicTime.Now[];
ICMP.Destroy[handle];
BEGIN
packetsPerSecond, msPerPacket: REAL;
seconds: LONG CARDINAL _ BasicTime.Period[from: start, to: finish];
IF seconds = 0 THEN seconds _ 1;
packetsPerSecond _ REAL[sent]/REAL[seconds];
IF data.good = 0 THEN msPerPacket _ 0
ELSE msPerPacket _ 1000.0*seconds/data.good;
IO.PutF[data.log, "%G packets sent in %G seconds =>\n\t", [integer[sent]], [cardinal[seconds]]];
IO.PutF[data.log, "%1.2F packets/second.\n", [real[packetsPerSecond]] ];
IO.PutF[data.log, "%G bytes received in %G seconds =>\n\t", [integer[bytes]], [cardinal[seconds]]];
IO.PutF[data.log, "%1.0F bits/second => ", [real[8.0*bytes/seconds]] ];
IO.PutF[data.log, "%G ms/packet.\n", [real[msPerPacket]] ];
PrintPercent[data, data.good, sent, "Packets echoed OK"];
PrintPercent[data, mashed, sent, "Packets with bad data"];
PrintPercent[data, missed, sent, "Packets missed"];
PrintPercent[data, late, sent, "Late Packets"];
PrintPercent[data, bogus, sent, "Packets with wrong type"];
IO.Flush[data.log];
END; };

InitDelayHist: PROC [data: ClientData] = {
data.minDelay _ INT.LAST;
data.maxDelay _ INT.FIRST;
data.delayHist _ ALL[0]; };

AddToDelayHist: PROC [data: ClientData, micro: INT] = {
FOR d: DelayRange IN DelayRange DO  -- Slow but clean
IF delayTime[d] < micro THEN LOOP;
data.delayHist[d] _ data.delayHist[d] + 1;
EXIT;
REPEAT FINISHED => ERROR;
ENDLOOP;
data.minDelay _ MIN[data.minDelay, micro];
data.maxDelay _ MAX[data.maxDelay, micro]; };

PrintDelayHist: PROC [data: ClientData] = {
total: INT _ 0;
IF data.good = 0 THEN RETURN;
IO.PutF[data.log, "    Incremental      Cumulative    Microseconds\n"];
FOR d: DelayRange IN DelayRange DO
IF data.delayHist[d] = 0 THEN LOOP;
total _ total + data.delayHist[d];
IO.PutF[data.log, "%8G", [integer[data.delayHist[d]]]];
IO.PutF[data.log, "%7.2F%%", [real[100.0*data.delayHist[d]/data.good]]];
IO.PutF[data.log, "%8G", [integer[total]]];
IO.PutF[data.log, "%7.2F%%", [real[100.0*total/data.good]]];
IO.PutF[data.log, "%9G\n", [integer[delayTime[d]]]];
ENDLOOP;
IO.PutF[data.log, "The min delay was %G microseconds.\n", [integer[data.minDelay]]];
IO.PutF[data.log, "The max delay was %G microseconds.\n", [integer[data.maxDelay]]]; };

TimeProc: Buttons.ButtonProc = {
data: ClientData _ NARROW[clientData];
target: ROPE = ViewerTools.GetContents[data.target];
Time[data, target]; };

Time: PROC [data: ClientData, target: ROPE] = TRUSTED {
Pair: TYPE = MACHINE DEPENDENT RECORD [a, b: CARDINAL]; -- used for word swap
Flip: PROC [Pair] RETURNS [INT] = TRUSTED MACHINE CODE
BEGIN PrincOps.zEXCH; END;
Flop: PROC [INT] RETURNS [Pair] = TRUSTED MACHINE CODE
BEGIN PrincOps.zEXCH; END;
handle: ICMP.Handle;
dg: IPDefs.Datagram;
icmp: LONG POINTER TO ICMP.BodyRec;
times: LONG POINTER TO ARRAY {orig, recv, tran} OF Pair;
packetStart: BasicTime.Pulses;
Report[data, "\nGetting Time from ", target, " "];
IF ~FindPath[data, target] THEN RETURN;
handle _ ICMP.Create[him: data.where];
dg _ NEW [IPDefs.DatagramRec];
icmp _ LOOPHOLE[@dg.data];
times _ LOOPHOLE[@icmp.data];
icmp.type _ ICMP.Timestamp;
times[orig] _ Flop[SecondsSinceMidnight[]];
times[recv] _ [CARDINAL.LAST, CARDINAL.LAST];
times[tran] _ [CARDINAL.LAST, CARDINAL.LAST];
packetStart _ BasicTime.GetClockPulses[];
ICMP.Send[handle, dg, ICMP.minLength+12];
UNTIL (dg _ ICMP.Receive[handle, 10000]) = NIL DO
icmp _ LOOPHOLE[@dg.data];
times _ LOOPHOLE[@icmp.data];
SELECT TRUE FROM
dg.dataLength # ICMP.minLength+12 => IO.PutRope[data.log, "Wrong Length"];
icmp.type # ICMP.TimestampReply => IO.PutRope[data.log, "Wrong Type"];
ENDCASE => {
now: BasicTime.GMT _ BasicTime.Now[];
packetStop: BasicTime.Pulses _ BasicTime.GetClockPulses[];
microseconds: LONG CARDINAL _ BasicTime.PulsesToMicroseconds[packetStop-packetStart];
IO.PutF[data.log, "Orig time is %G.\n", [rope[NetTimeToRope[Flip[times[orig]]]]]];
IO.PutF[data.log, "Recv time is %G.\n", [rope[NetTimeToRope[Flip[times[recv]]]]]];
IO.PutF[data.log, "Tran time is %G.\n", [rope[NetTimeToRope[Flip[times[tran]]]]]];
IO.PutF[data.log, "The flight time was %G ms.\n", [integer[microseconds/1000]]];
EXIT; };
dg _ NIL;
ENDLOOP;
ICMP.Destroy[handle]; };

SecondsSinceMidnight: PROC RETURNS [ms: INT] = {
secondsPerDay: INT _ 86400;
now: BasicTime.Unpacked _ BasicTime.Unpack[BasicTime.Now[]];
ms _ secondsPerDay;
IF now.dst = yes THEN ms _ ms - 3600;
ms _ ms + LONG[now.hour]*3600;
ms _ ms + LONG[(now.minute + now.zone)]*60;
ms _ ms + now.second;
ms _ ms MOD secondsPerDay;
ms _ ms * 1000; };

NetTimeToRope: PROC [ms: INT] RETURNS [rope: ROPE] = {
seconds, fraction: INT;
IF ms < 0 THEN RETURN["Unknown"];
seconds _ ms/1000;
fraction _ ms MOD 1000;
RETURN[IO.PutFR["%R.%03G", [integer[seconds]], [integer[fraction]] ]]; };

PrintPercent: PROC [data: ClientData, x, sent: INT, name: ROPE] = {
IF x = 0 THEN RETURN;
IO.PutF[data.log, "%8G %7.2F%%  %G\n", [integer[x]], [real[100.0*x/sent]], [rope[name]] ]; };

FindPath: PROC [data: ClientData, target: ROPE] RETURNS [BOOLEAN] = TRUSTED {
where: LIST OF IPDefs.Address;
IF IPName.LoadCacheFromName[target, TRUE, TRUE] = down THEN {
IO.PutF[data.log, "Can't load name Cache."]; RETURN[FALSE]; };
where _ IPName.NameToAddress[target];
IF where = NIL THEN {IO.PutF[data.log, "Name not found."]; RETURN[FALSE]; };
data.where _ where.first;
Report[data, "= ", IPName.AddressToName[data.where]];
Report[data, " = ", IPName.AddressToRope[data.where], ".\n"];
RETURN[TRUE]; };

Report: PROC [data: ClientData, r1,r2,r3,r4: ROPE _ NIL] = TRUSTED {
IF r1 # NIL THEN {IO.PutRope[data.log, r1]};
IF r2 # NIL THEN {IO.PutRope[data.log, r2]};
IF r3 # NIL THEN {IO.PutRope[data.log, r3]};
IF r4 # NIL THEN {IO.PutRope[data.log, r4]}; };

MakeRule: PROC [parent, sibling: Viewer] RETURNS [child: Viewer] = {
child _ Rules.Create[
info: [parent: parent, border: FALSE,
wy: IF sibling = NIL THEN 0 ELSE sibling.wy + sibling.wh + 2, wx: 0, ww: parent.ww, wh: 1],
paint: FALSE ];
Containers.ChildXBound[parent, child]; };

ButtonWidth: PROC [r: ROPE] RETURNS [width: INT] = {
RETURN[Real.Round[ImagerFont.RopeEscapement[VFonts.DefaultFont[], r].x + 6]]};

MakeButton: PROC [parent, sibling: Viewer, data: REF ANY, name: ROPE, proc: Buttons.ButtonProc] RETURNS[child: Viewer] = {
child _ Buttons.Create[
info: [name: name, parent: parent, border: TRUE,
wy: sibling.wy, wx: sibling.wx + buttonWidth - 1, ww: buttonWidth],
proc: proc,
clientData: data,
fork: TRUE,
paint: FALSE]; };

SelectorProc: TYPE = PROC [parent: Viewer, clientData: REF, value: ATOM];
Selector: TYPE = REF SelectorRec;
SelectorRec: TYPE = RECORD [
value: REF ATOM,
change: PROC [parent: Viewer, clientData: REF, value: ATOM],
clientData: REF,
buttons: LIST OF Buttons.Button,
values: LIST OF ATOM ];

MakeSelector: PROC
[name: ROPE, values: LIST OF ATOM, init: REF ATOM _ NIL, change: SelectorProc _ NIL, clientData: REF _ NIL, parent: Viewer, x, y: INTEGER]
RETURNS [child: Viewer] = {
selector: Selector _ NEW [SelectorRec _ [
value: IF init # NIL THEN init ELSE NEW [ATOM _ values.first],
change: change,
clientData: clientData,
buttons: NIL,
values: values ] ];
last: LIST OF Buttons.Button _ NIL;
child _ Labels.Create[info: [name: name, parent: parent, border: FALSE, wx: x, wy: y] ];
FOR a: LIST OF ATOM _ values, a.rest UNTIL a = NIL DO
child _ Buttons.Create[
info: [name: Atom.GetPName[a.first], parent: parent, border: TRUE, wx: child.wx + child.ww + 2, wy: child.wy],
proc: SelectorHelper, clientData: selector, fork: TRUE, paint: TRUE];
IF last = NIL THEN last _ selector.buttons _ CONS[first: child, rest: NIL]
ELSE { last.rest _ CONS[first: child, rest: NIL]; last _ last.rest };
IF a.first = selector.value^ THEN Buttons.SetDisplayStyle[child, $WhiteOnBlack];
ENDLOOP; };

SelectorHelper: Buttons.ButtonProc = {
self: Buttons.Button = NARROW[parent];
selector: Selector = NARROW[clientData];
buttons: LIST OF Buttons.Button _ selector.buttons;
FOR a: LIST OF ATOM _ selector.values, a.rest UNTIL a = NIL DO
IF self = buttons.first THEN {
selector.value^ _ a.first;
IF selector.change # NIL THEN selector.change[self.parent, selector.clientData, a.first];
Buttons.SetDisplayStyle[buttons.first, $WhiteOnBlack]; }
ELSE Buttons.SetDisplayStyle[buttons.first, $BlackOnWhite];
buttons _ buttons.rest;
ENDLOOP; };

BoolProc: TYPE = PROC [parent: Viewer, clientData: REF, value: BOOL];
Bool: TYPE = REF BoolRec;
BoolRec: TYPE = RECORD [
value: REF BOOL,
change: BoolProc,
clientData: REF,
button: Viewer ];

MakeBool: PROC
[name: ROPE, init: REF BOOL, change: BoolProc _ NIL, clientData: REF _ NIL, parent, sibling: Viewer, x, y: INTEGER _ 0]
RETURNS [child: Viewer] = {
bool: Bool _ NEW [BoolRec _ [
value: IF init # NIL THEN init ELSE NEW [BOOL _ TRUE],
change: change,
clientData: clientData,
button: NIL ] ];
IF x = 0 THEN x _ sibling.wx + sibling.ww + 10;
IF y = 0 THEN y _ sibling.wy;
child _ Buttons.Create[
info: [name: name, parent: parent, border: TRUE, wx: x, wy: y],
proc: BoolHelper, clientData: bool, fork: TRUE, paint: TRUE];
bool.button _ child;
IF bool.value^ THEN Buttons.SetDisplayStyle[child, $WhiteOnBlack]; };

BoolHelper: Buttons.ButtonProc = {
self: Buttons.Button = NARROW[parent];
bool: Bool = NARROW[clientData];
bool.value^ _ ~bool.value^;
IF bool.value^ THEN Buttons.SetDisplayStyle[bool.button, $WhiteOnBlack]
ELSE Buttons.SetDisplayStyle[bool.button, $BlackOnWhite];
IF bool.change # NIL THEN bool.change[self.parent, bool.clientData, bool.value^]; };

MakeLabel: PROC [parent, sibling: Viewer, name: ROPE] RETURNS [child: Viewer] = {
child _ Labels.Create[
info: [name: name, parent: parent, border: FALSE,
wy: sibling.wy + sibling.wh + (IF sibling.class.flavor = $Button THEN -1 ELSE 2),
wx: 2],
paint: FALSE ]; };

MakeLabeledText: PROC [
parent, sibling: Viewer, name, data: ROPE, prev: Viewer,
newline: BOOL _ TRUE, labelWidth: INT _ 0, dataWidth: INT _ 50] RETURNS [child: Viewer] = {
x: INTEGER = IF newline THEN 2 ELSE sibling.wx + sibling.ww + 10;
y: INTEGER = IF newline THEN sibling.wy + sibling.wh + 1 ELSE sibling.wy;
IF labelWidth = 0 THEN labelWidth _ ButtonWidth[name];
child _ ViewerTools.MakeNewTextViewer[
info: [parent: parent, wh: buttonHeight, ww: dataWidth, scrollable: FALSE,
data: IF prev = NIL THEN data ELSE ViewerTools.GetContents[prev],
border: FALSE,
wx: x + labelWidth + 2, wy: y],
paint: FALSE ];
Containers.ChildXBound[parent, child];
[] _ Buttons.Create[
info: [name: name, parent: parent, wh: buttonHeight, border: FALSE, wx: x, wy: y],
proc: LabeledTextProc, clientData: child, fork: FALSE, paint: FALSE];
RETURN[child]; };

LabeledTextProc: Buttons.ButtonProc = {
text: Viewer = NARROW[clientData];
SELECT mouseButton FROM
red => ViewerTools.SetSelection[text, NIL];
yellow => NULL;
blue => { ViewerTools.SetContents[text, NIL]; ViewerTools.SetSelection[text, NIL] };
ENDCASE => ERROR; };

Commander.Register["ICMPEchoTool", Create, "Echo ICMP packets to the Arpa Internet."];

END.




žICMPEchoTool.mesa
Hal Murray July 6, 1985 3:44:12 pm PDT
John Larson, July 12, 1987 2:18:59 am PDT
Viewer layout parameters
parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL
parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL
parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL
parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL
parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL
parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL
parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL
Κ€˜š
œ™Icode™&K™)—J˜š
Οk	˜	Jšœœ˜šœ
œ˜Jšœœ?˜R—Jšœœ/˜<Jšœ
œ˜(Jšœœ$˜4Jšœœ#˜0Jšœœ˜"Jšœ
œœ	˜6Jšœœ
˜Jšœœ˜Jšœ	œ	˜Jšœœ	˜Jšœœœ˜Jšœœ
˜Jšœœ˜'Jšœœ
˜Jšœ	œ˜%Jšœ
œM˜\Jšœœ=˜NJšœœ˜JšœœX˜dJšœœB˜Nšœ
œu˜J˜——šΟnœœ
˜š
˜JšœDœUœ˜«
—Jš
˜J˜Jšœœœ
˜Jšœœœ
œ
˜Jšœœ˜%™Jšœœ˜Jšœ
œ˜-—J˜Jšœœœ˜%šœœœ˜Jšœœœ
˜Jšœœœ
˜Jšœœœ
˜Jšœœœ
˜Jš
œ+˜+Jšœœ
œœœœ˜#Jšœœ
œœœœ˜#Jšœœ
œœœœ˜#Jšœ
œ
œœœœ˜+Jšœ0œ
˜4Jšœœ˜Jšœœ˜Jš	œœœ
œœ˜.—J˜šœœ˜Jš
œQ˜QJš
œA˜AJš
œX˜X—J˜šœœœ
œ˜&Jš
œ)˜)Jš
œ)˜)Jš
œ)˜)Jš
œ)˜)Jš
œ˜Jš
œG˜GJš
œS˜SJš
œ_˜_Jšœ`œ
œ˜k—J˜šΠbnœœ˜)Jšœœ˜+Jšœœ
˜#š
œ!˜!J˜Jšœ5œœ˜P—Jš
œ+˜+J˜š
œ˜Jšœ=œœ˜L—š
œ4˜4JšœVœ˜]—Jš
œ$˜$Jš
œ$˜$Jš
œ!˜!Jš
œ ˜ JšœO˜QJš
œ˜J˜—šž
œœ
œ+˜DJšœœ
˜š
œ!˜!Jšœœœ'˜^—J˜%Jš
œi˜iJš
œ]˜]Jš
œ]˜]Jš
œn˜nš
œ&˜&J˜
J˜J˜Jšœœ˜*Jš
œ˜Jšœ	œ
˜Jš
œ!˜!—š
œ'˜'J˜
J˜J˜Jš
œ ˜ Jš
œ˜Jšœ	œ˜—Jš
œ˜š
œ&˜&J˜
J˜J˜J˜Jš
œ˜—J˜J˜(Jš
œ8˜8Jš
œ:˜:Jš
œ8˜8Jš
œ8˜8J˜š
œ
˜
Jšœœ˜Jšœœ˜)Kšœnœ˜uJšœ
œ
œD˜QJšœœ(˜>Jš
œR˜R—J˜J˜—šŸ	œ˜!Jš
œL™LJšœœ
˜&Jš
œ˜J˜—šžœœ˜"Jšœœ(˜4Jšœ
œ
œ˜#Jš
œ+˜+Jšœœ
œ
˜'Jšœœ
˜Jšœœ˜J˜—šŸœ˜ Jš
œL™LJšœœ
˜&Jš
œ˜Jš
œ˜J˜—šŸœ˜ Jš
œL™LJšœœ
˜&Jš
œ˜J˜—šžœœœ˜)Jšœœ
˜Jšœ
œ
œ
œ˜'Jšœœ˜J˜—šžœœœ˜)Jšœœ
˜Jšœ#œ˜+Jšœœ˜Jšœœ˜Jšœ
œ˜&Jšœœ(˜8Jšœœœ˜%Jšœœœ˜%Jšœœœ˜&Jšœœ
œ˜3Jšœ
œ)˜:Jšœœ˜Jšœœ	˜Jšœ	œ
˜
š
œ>˜>Jšœ0˜2Jš
œ˜Jšœ˜—Jšœ
œ˜#Jšœ
œ˜#šœ
œ˜Jšœœ
˜
š
œ:˜:Jšœ/˜1Jš
œ˜Jšœ˜—Jšœœ˜Jšœœ˜Jš
œ˜JšœJ˜L—J˜J˜J˜šœ˜š	œœ
œœ˜FJš
œ*˜*Jšœœ˜/Jš	œœœ
œœ˜=Icode2šœœ
œ
œ
œœ˜8Jšœœ˜Jšœ/œ˜5šœœ
œ˜)Jšœœœ
˜#—Jš
œ)˜)Lšœ˜J˜šœœœ
˜3Lšœœ˜šœ
œ
˜šœœ˜Jš
œ˜Jšœ@˜B—šœ!œ˜?Jš
œœœ
œœ
˜I—šœ˜Jš
œ(˜(Jš
œM˜Mšœœ
œ˜)šœœœ˜#Jšœ˜Jš
œ˜Jšœ	˜
—Jšœ
˜—Jšœœ
œ˜-Jš
œ˜Jš
œ!˜!Jšœ˜——Jšœœ
˜	Jšœ	œ
˜Jšœ
˜—Jšœœ
œ˜Jšœœœ
œ˜LJšœ
˜—Jš
œ
œ
œœ
œ˜NJšœ
˜—Jšœ˜Jš
œ˜Jšœ˜Jš
˜Jšœœ
˜$Jšœ	œ
œ-˜CJšœ
œ
˜ Jšœœœ
˜,Jšœœ˜%Jšœ(˜,Jšœ^˜`JšœF˜HJšœa˜cJšœE˜GJšœ9˜;Jš
œ9˜9J˜:J˜3J˜/J˜;Jšœ˜Jšœ˜J˜—šž
œœ˜*Jšœœ
œ
˜Jšœœ
œ
˜Jšœœ˜J˜—šžœœœ˜7šœœœΟc˜5Jšœœ
œ
˜"Jš
œ*˜*Jšœ
˜Jšœ
œœ
˜Jšœ
˜Jšœœ˜*Jšœœ˜-J˜——šžœœ˜+Jšœœ˜Jšœœ
œ
˜JšœE˜Gšœœ˜"Jšœœ
œ
˜#Jš
œ"˜"Jšœ5˜7JšœF˜HJšœ)˜+Jšœ:˜<Jšœ2˜4Jšœ
˜—JšœR˜TJšœV˜X—šŸœ˜ Jš
œL™LJšœœ
˜&Jšœœ(˜4Jš
œ˜J˜—šžœœœœ˜7Lšœœœ
	œ
œœ ˜Mš
žœœœœœ
œ
˜6Lšœœ
˜—š
žœœœœ
œ
œ
˜6Lšœœ
˜—Jšœœ˜Jš
œ˜Lš	œœ
œ
œ
œ	˜#Lšœœ
œ
œ
œœ˜8Jš
œ˜Jš
œ2˜2Jšœœ
œ
˜'Jšœ	œ˜&Jšœœ˜Lšœœ˜Lšœœ
˜Lšœœ˜Lš
œ+˜+Lš	œœ
œœ
œ˜-Lš	œœ
œœ
œ˜-Jš
œ)˜)Lšœœ˜)šœœœ
˜1Lšœœ˜Lšœœ
˜šœ
œ
˜Jšœœœ#˜JJšœœœ!˜Fšœ˜Jšœœ˜%Jš
œ:˜:Jšœœ
œ:˜UJšœP˜RJšœP˜RJšœP˜RJšœN˜PJšœ˜——Jšœœ
˜	Jšœ
˜—Jšœ˜J˜—šžœœ
œœ˜0Jšœœ	˜Jš
œ<˜<Jš
œ˜Jšœœ˜%Jšœ
œ˜Jšœ
œ˜+Jš
œ˜Jšœœ˜Jš
œ˜J˜—š
ž
œœœœœ˜6Jšœœ
˜Jšœœ
œ˜!J˜Jšœœ˜Jšœ
œ@˜I—J˜šžœœœœ˜CJšœœ
œ
˜Jšœ[˜]—J˜šžœœœœœœ˜MJšœœ
œ˜šœ"œœ	œ˜=Jšœ+œ
œ˜>—Jš
œ%˜%Jšœ	œ
œœ$œ
œ˜LJ˜Jš
œ5˜5Jš
œ=˜=Jšœ
œ˜J˜—š
žœœ!œœœ˜DJšœœ
œœ˜,Jšœœ
œœ˜,Jšœœ
œœ˜,Jšœœ
œœ˜/—J˜šžœœœ˜D˜šœœ
˜%Jš	œœœ
œœ;˜[—Jšœœ˜—Jš
œ)˜)J˜—š
žœœœœ	œ˜4JšœH˜NJ˜—šž
œœ!œ
œœœ˜z˜šœ+œ
˜0J˜C—J˜J˜Jšœœ
˜Jšœœ˜—J˜—Jš	œœœœ	œ˜IJšœ
œœ
˜!šœ
œœ˜Jšœœ
œ
˜Jšœœœ	œ˜<Jšœœ
˜Jšœ	œ
œ˜ Jšœœ
œ
œ˜—J˜šžœ˜Kšœœ
œ
œ
œœ
œœœœœœ
˜Š
Kšœ˜šœœ˜)Jš
œœœ
œœ
œœ˜>J˜J˜Jšœ	œ
˜
J˜—Jšœœ
œœ
˜#JšœAœ˜Xš
œœ
œ
œœœ
˜5š
œ˜Kšœ=œ-˜nJšœ2œ	œ˜E—Jš
œœ
œœœ
˜JJšœœœ˜EJšœœ/˜PJšœ˜——J˜šŸœ˜&Jš
œL™LJšœœ	˜&Jšœœ
˜(Jšœ	œ
œ#˜3š
œœ
œ
œœœ
˜>šœœ˜J˜Jšœœ
œ<˜YJš
œ8˜8—Jšœ7˜;J˜Jšœ˜——J˜Jš	œ
œœœ	œ˜EJšœœœ	˜šœ	œœ˜Jšœœ
œ
˜Jš
œ˜Jšœœ
˜Jš
œ˜—J˜šžœ˜Kšœœœ
œœœœ!œ˜wKšœ˜šœ
œ
˜Jšœœœ
œœ
œœœ˜6J˜Jš
œ˜Jšœœ˜—Jšœœ"˜/Jšœœ˜š
œ˜Kšœ+œ˜?Jšœ*œ	œ˜=—Jš
œ˜Jšœ
œ2˜E—J˜šŸ
œ˜"Jš
œL™LJšœœ	˜&Jšœ
œ
˜ Jš
œ˜Jšœ
œ4˜GJšœ5˜9Jšœœ
œ<˜U—šž	œœ!œœ˜Q˜šœ+œ
˜1Jšœœ œœ˜QJ˜—Jšœœ˜——J˜šžœœ˜Jš
œ%œœœœœœ˜”
Jš	œœœ	œœ˜AJš	œœœ	œœ˜IJšœœ ˜6˜&šœDœ
˜JJš	œœœ
œœ˜AJšœœ
˜Jš
œ˜—Jšœœ˜—Jš
œ&˜&˜Jšœ=œ˜RJšœ0œ	œ˜E—Jšœ˜J˜—šŸœ˜'Jš
œL™LJšœœ
˜"šœ
˜Jšœ&œ˜+Jšœ
œ
˜Jšœ(œ"œ˜TJšœœ˜——J˜š
œV˜VJ˜—Jšœ
˜J˜J˜J˜—J˜—…—M²fτ