-- Copyright (C) 1984, 1985  by Xerox Corporation. All rights reserved. 
-- PhoneDriver.mesa, HGM,  9-Apr-85 22:17:39

DIRECTORY
  Environment USING [Byte],
  Inline USING [BITXOR, LowHalf],
  Process USING [DisableTimeout, InitializeCondition, MsecToTicks, SetPriority, Yield],
  ProcessPriorities USING [priorityPageFaultHigh],  -- Below Ethernet Drivers
  SpecialRuntime USING [AllocateNakedCondition],
  String USING [EqualString],
  System USING [
    GetClockPulses, GetGreenwichMeanTime, HostNumber, localHostNumber,
    MicrosecondsToPulses, nullHostNumber, nullNetworkNumber, Pulses, PulsesToMicroseconds],

  Buffer USING [AccessHandle, Buffer, MakePool, NSBuffer, PupBuffer, ReturnBuffer, Type],
  CommUtil USING [AllocateIocbs],
  Driver USING [
    NetworkObject, Network, PutOnGlobalDoneQueue,
    AddDeviceToChain, GetInputBuffer, PutOnGlobalInputQueue],
  DriverTypes USING [DeviceType, Encapsulation],
  PhoneNetFriends USING [NetEnumerator, nullNetEnumerate, PhoneNetInfo],
  PhoneNetExtras USING [nsCongestion, nsTooGreedy, pupCongestion, pupTooGreedy],
  PupTypes USING [PupHostID, PupErrorCode],

  DESFace USING [
    Block, CorrectParity, ECBDecrypt, ECBEncrypt, nullKey, Key],
  PhoneCreate USING [],
  PhoneFace USING [
    controlBlockSize, GetPacketLength, GetPacketsMissed, GetRecvStatus, GetSendStatus,
    QueueInput, QueueOutput, ResetLine, Status, TurnOn];

PhoneDriver: MONITOR LOCKS lock­
  IMPORTS
    Inline, Process, SpecialRuntime, String, System,
    Buffer, CommUtil, DESFace, Driver, PhoneFace
  EXPORTS Buffer, PhoneCreate, PhoneNetFriends =
  BEGIN
  
  -- EXPORTed TYPEs
  Network: PUBLIC TYPE = Driver.Network;
  
  Byte: TYPE = Environment.Byte;

  maxHiPriWords: CARDINAL = (2 + 50 + 22)/2; -- 50 data bytes in a pup
  maxQueueDepth: CARDINAL ¬ 15; -- For each of Pup, NS, ...
  maxForwarderDepth: CARDINAL ¬ 10;
  maxConnectionDepth: CARDINAL ¬ 5;
  

  PhonePacketType: TYPE = MACHINE DEPENDENT{
    pupPhonePacket(100B),
    nsPhonePacket(300B),
    turnAroundPhonePacket(301B),
    turnAroundMTSPhonePacket(302B),
    terminatePhonePacket(303B),
    terminateAckPhonePacket(304B),
    (LAST[Byte])};

  Encapsulation: TYPE = MACHINE DEPENDENT RECORD [
    SELECT OVERLAID DriverTypes.DeviceType FROM
      phonenet => [
	framing0, framing1, framing2, framing3, framing4, framing5: Byte,
	recognition: Byte, -- 0 for auto recognition of OISCP vs SDLC/HDLC
	pnType: PhonePacketType,
	pnSrcID: System.HostNumber],
      ENDCASE];

  phoneEncapsulationOffset: CARDINAL = 3;
  phoneEncapsulationBytes: CARDINAL = 8;

  encapsulationTrap: BOOLEAN [TRUE..TRUE] =
    (SIZE[Encapsulation] = SIZE[DriverTypes.Encapsulation]);
  
  lock: POINTER TO MONITORLOCK ¬ @myLock;
  myLock: MONITORLOCK;

  Info: TYPE = LONG POINTER TO InfoRecord;
  InfoRecord: TYPE = RECORD [
    lineNumber: CARDINAL,
    currentSendBuffer: Buffer.Buffer,  -- Beware: this buffer may be encrypted
    firstHiSendBuffer, lastHiSendBuffer: Buffer.Buffer,
    firstLoSendBuffer, lastLoSendBuffer: Buffer.Buffer,
    packetsOnSendQueue: CARDINAL,
    timeSendStarted: System.Pulses,
    firstRecvBuffer, lastRecvBuffer: Buffer.Buffer,
    timeLastRecv: System.Pulses,
    missed: CARDINAL,
    bitsPerSecond: LONG CARDINAL,
    network: Driver.NetworkObject,
    stats: PhoneNetFriends.PhoneNetInfo,
    loophole: CrapForINRLoophole,
    encrypt: BOOLEAN,
    dlion: BOOLEAN,
    key: DESFace.Key,
    pool: Buffer.AccessHandle,
    sendIocb: LONG POINTER,
    recvIocbs: LONG POINTER,
    next: Info];
    
  CrapForINRLoophole: TYPE = MONITORED RECORD [
    clientData: LONG UNSPECIFIED,
    lineNumber: CARDINAL];

  info: InfoRecord ¬ [
    lineNumber: ,
    currentSendBuffer: NIL,
    firstHiSendBuffer: NIL,
    lastHiSendBuffer: NIL,
    firstLoSendBuffer: NIL,
    lastLoSendBuffer: NIL,
    packetsOnSendQueue: 0,
    timeSendStarted: ,
    firstRecvBuffer: NIL,
    lastRecvBuffer: NIL,
    timeLastRecv: ,
    missed: 0,
    bitsPerSecond: 0,
    network: [
      next: NIL,
      decapsulateBuffer: Decapsulate,
      encapsulateAndSendPup: SendPup,
      encapsulateAndSendNS: SendNS,
      sendRawBuffer: SendRawBuffer,
      encapsulateAndForwardPup: ForwardPup,
      encapsulateAndForwardNS: ForwardNS,
      activateDriver: ActivateDriver,
      deactivateDriver: KillDriver,
      deleteDriver: KillDriver,
      changeNumberOfInputBuffers: NIL,
      index: ,
      netNumber: System.nullNetworkNumber,
      pupNetNumber: 0,
      pupHostNumber: 0,
      device: phonenet,
      alive: FALSE,
      buffers: 10,  -- This should be overkill
      pupStats: NIL,
      statsLevel0: @info.loophole,
      statsLevel1: NIL],
    stats: [
      state: data,
      timeStarted: System.GetGreenwichMeanTime[],
      timeConnectionEstablished: System.GetGreenwichMeanTime[],
      remoteHostNumber: System.nullHostNumber,
      protocolVersion: old,
      lineNumber: NULL,
      duplexity: full,
      lineSpeed: bps9600,
      speed: 0, -- Observed, Kilobits/second
      negotiationMode: NULL,
      ourEntityClass: NULL,
      theirEntityClass: NULL,
      halfDuplexMode: NULL,
      hardwareStatsAvailable: TRUE,
      clientData: 0,
      clientHostNumber: NULL,
      sendQueueLength: 0,
      stats: ALL [0] ],
    loophole: [, @info.stats, ],
    encrypt: FALSE,
    dlion: FALSE,
    key: TRASH,
    pool: NIL,
    sendIocb: NIL,
    recvIocbs: NIL,
    next: NIL ];

  me: System.HostNumber = System.localHostNumber;
  
  -- Shared by all lines
  interrupt, watcher: PROCESS ¬ NIL;
  pleaseStop: BOOLEAN ¬ FALSE;
  hardware: LONG POINTER TO CONDITION ¬ NIL;
  interruptBits: WORD ¬ 0;
  
  
  DuplicateLineNumber: ERROR = CODE;
  


  -- **************** Interface to Router(s) ****************

  Decapsulate: PROCEDURE [b: Buffer.Buffer] RETURNS [type: Buffer.Type] =
    BEGIN
    encapsulation: LONG POINTER TO Encapsulation = LOOPHOLE[@b.encapsulation];
    bytes: CARDINAL ¬ 2*b.driver.length;
    IF bytes < phoneEncapsulationBytes THEN GOTO Rejected;
    IF info.encrypt THEN
      BEGIN
      words: CARDINAL ¬ (b.driver.length+1)/2;
      blocks: CARDINAL = (words+SIZE[DESFace.Block]-1)/SIZE[DESFace.Block];
      data: LONG POINTER = @b.encapsulation + phoneEncapsulationOffset;
      DESFace.ECBDecrypt[info.key, blocks, data, data];
      END;
    SELECT encapsulation.pnType FROM
      nsPhonePacket =>
        BEGIN
	IF bytes < b.ns.pktLength THEN GOTO Rejected;
	type ¬ ns;
	END;
      pupPhonePacket =>
        BEGIN
	IF bytes < b.pup.pupLength THEN GOTO Rejected;
        type ¬ pup;
	END;
      ENDCASE => GOTO Rejected;
    info.stats.remoteHostNumber ¬ encapsulation.pnSrcID;
    EXITS Rejected =>
      BEGIN
      type ¬ rejected;
      StatIncr[@info.stats.stats[pktsRejected]];
      END;
    END;
    
  SendPup: ENTRY PROCEDURE [b: Buffer.PupBuffer, systemElem: PupTypes.PupHostID] =
    BEGIN
    high: BOOLEAN;
    friends, pups: CARDINAL ¬ 0;
    encapsulation: LONG POINTER TO Encapsulation = LOOPHOLE[@b.encapsulation];
    encapsulation­ ¬ [
      phonenet[
	framing0: 0, framing1: 0, framing2: 0, framing3: 0, framing4: 0,
	framing5: 0, recognition: 0,
	pnType: pupPhonePacket, pnSrcID: me] ];
    b.driver.length ¬
      (b.pup.pupLength + 1 + phoneEncapsulationBytes)/2;
    [friends, pups, ] ¬ CountFriends[b, info.firstLoSendBuffer, friends, pups];
    high ¬ b.driver.length < maxHiPriWords AND (friends = 0);
    [friends, pups, ] ¬ CountFriends[b, info.firstHiSendBuffer, friends, pups];
    IF friends > maxConnectionDepth THEN
      BEGIN
      Driver.PutOnGlobalDoneQueue[b];
      StatIncr[@info.stats.stats[connTooGreedy]];
      StatIncr[@info.stats.stats[PhoneNetExtras.pupTooGreedy]];
      RETURN;
      END;
    IF pups > maxQueueDepth THEN
      BEGIN
      Driver.PutOnGlobalDoneQueue[b];
      StatIncr[@info.stats.stats[congestion]];
      StatIncr[@info.stats.stats[PhoneNetExtras.pupCongestion]];
      RETURN;
      END;
    QueueOutputBuffer[b, high];
    StatIncr[@info.stats.stats[pupSent]];
    END;

  SendNS: ENTRY PROCEDURE [b: Buffer.NSBuffer, host: System.HostNumber] =
    BEGIN
    high: BOOLEAN;
    friends, ns: CARDINAL ¬ 0;
    encapsulation: LONG POINTER TO Encapsulation = LOOPHOLE[@b.encapsulation];
    encapsulation­ ¬ [
      phonenet[
	framing0: 0, framing1: 0, framing2: 0, framing3: 0, framing4: 0,
	framing5: 0, recognition: 0,
	pnType: nsPhonePacket, pnSrcID: me] ];
    b.driver.length ¬
      (b.ns.pktLength + 1 + phoneEncapsulationBytes)/2;
    [friends, ns, ] ¬ CountFriends[b, info.firstLoSendBuffer, friends, ns];
    high ¬ b.driver.length < maxHiPriWords AND (friends = 0);
    [friends, ns, ] ¬ CountFriends[b, info.firstHiSendBuffer, friends, ns];
    IF friends > maxConnectionDepth THEN
      BEGIN
      Driver.PutOnGlobalDoneQueue[b];
      StatIncr[@info.stats.stats[connTooGreedy]];
      StatIncr[@info.stats.stats[PhoneNetExtras.nsTooGreedy]];
      RETURN;
      END;
    IF ns > maxQueueDepth THEN
      BEGIN
      Driver.PutOnGlobalDoneQueue[b];
      StatIncr[@info.stats.stats[congestion]];
      StatIncr[@info.stats.stats[PhoneNetExtras.nsCongestion]];
      RETURN;
      END;
    QueueOutputBuffer[b, high];
    StatIncr[@info.stats.stats[nsSent]];
    END;

  SendRawBuffer: ENTRY PROCEDURE [b: Buffer.Buffer] =
    BEGIN
    IF info.packetsOnSendQueue > maxQueueDepth THEN
      BEGIN
      Driver.PutOnGlobalDoneQueue[b];
      StatIncr[@info.stats.stats[congestion]];
      RETURN;
      END;
    QueueOutputBuffer[b, FALSE];
    StatIncr[@info.stats.stats[rawSent]];
    END;

  ForwardPup: ENTRY PROCEDURE [b: Buffer.PupBuffer, host: PupTypes.PupHostID]
    RETURNS [PupTypes.PupErrorCode] =
    BEGIN
    high: BOOLEAN;
    dup, lic, ate: BOOLEAN;
    friends, pups: CARDINAL ¬ 0;
    encapsulation: LONG POINTER TO Encapsulation = LOOPHOLE[@b.encapsulation];
    encapsulation­ ¬ [
      phonenet[
	framing0: 0, framing1: 0, framing2: 0, framing3: 0, framing4: 0,
	framing5: 0, recognition: 0,
	pnType: pupPhonePacket, pnSrcID: me] ];
    b.driver.length ¬
      (b.pup.pupLength + 1 + phoneEncapsulationBytes)/2;
    [friends, pups, dup] ¬ CountFriends[b, info.firstLoSendBuffer, friends, pups];
    high ¬ b.driver.length < maxHiPriWords AND (friends = 0);
    [friends, pups, lic] ¬ CountFriends[b, info.firstHiSendBuffer, friends, pups];
    [friends, pups, ate] ¬ CountFriends[b, info.currentSendBuffer, friends, pups];
    IF ((b.pup.pupType = aData OR b.pup.pupType = data) AND (dup OR lic OR ate) OR
      (b.pup.pupType = aData AND friends # 0 AND b.pup.pupLength = 22)) THEN {
      -- Barf, what an ugly hack to put into a gateway
      -- Duplicate data/aData OR (empty aData (probe) when something on the queue)
      StatIncr[@info.stats.stats[controlPktReceived]];
      RETURN[LOOPHOLE[10002]]; };
    IF friends > maxConnectionDepth THEN {
      StatIncr[@info.stats.stats[connTooGreedy]];
      StatIncr[@info.stats.stats[PhoneNetExtras.pupTooGreedy]];
      RETURN[gatewayResourceLimitsPupErrorCode]; };
    IF pups > maxForwarderDepth THEN {
      StatIncr[@info.stats.stats[congestion]];
      StatIncr[@info.stats.stats[PhoneNetExtras.pupCongestion]];
      RETURN[gatewayResourceLimitsPupErrorCode]; };
    QueueOutputBuffer[b, high];
    StatIncr[@info.stats.stats[pupSent]];
    RETURN[noErrorPupErrorCode];
    END;

  ForwardNS: ENTRY PROCEDURE [b: Buffer.PupBuffer, host: System.HostNumber] =
    BEGIN
    high: BOOLEAN;
    friends, ns: CARDINAL ¬ 0;
    encapsulation: LONG POINTER TO Encapsulation = LOOPHOLE[@b.encapsulation];
    encapsulation­ ¬ [
      phonenet[
	framing0: 0, framing1: 0, framing2: 0, framing3: 0, framing4: 0,
	framing5: 0, recognition: 0,
	pnType: nsPhonePacket, pnSrcID: me] ];
    b.driver.length ¬
      (b.ns.pktLength + 1 + phoneEncapsulationBytes)/2;
    [friends, ns, ] ¬ CountFriends[b, info.firstLoSendBuffer, friends, ns];
    high ¬ b.driver.length < maxHiPriWords AND (friends = 0);
    [friends, ns, ] ¬ CountFriends[b, info.firstHiSendBuffer, friends, ns];
    IF friends > maxConnectionDepth THEN
      BEGIN
      Driver.PutOnGlobalDoneQueue[b];
      StatIncr[@info.stats.stats[connTooGreedy]];
      StatIncr[@info.stats.stats[PhoneNetExtras.nsTooGreedy]];
      RETURN;
      END;
    IF ns > maxForwarderDepth THEN
      BEGIN
      Driver.PutOnGlobalDoneQueue[b];
      StatIncr[@info.stats.stats[congestion]];
      StatIncr[@info.stats.stats[PhoneNetExtras.nsCongestion]];
      RETURN;
      END;
    QueueOutputBuffer[b, high];
    StatIncr[@info.stats.stats[nsSent]];
    END;

  CountFriends: INTERNAL PROCEDURE [
    b: Buffer.Buffer, head: Buffer.Buffer, friends, neighbors: CARDINAL]
    RETURNS [newFriends, newNeighbors: CARDINAL, headerMatch: BOOLEAN] =
    BEGIN
    encapsulation: LONG POINTER TO Encapsulation = LOOPHOLE[@b.encapsulation];
    headerMatch ¬ FALSE;
    SELECT encapsulation.pnType FROM
      pupPhonePacket => {
	maybe: Buffer.PupBuffer ¬ head;
	UNTIL maybe = NIL DO
          encap: LONG POINTER TO Encapsulation = LOOPHOLE[@maybe.encapsulation];
	  IF encap.pnType = pupPhonePacket THEN {
	    neighbors ¬ neighbors + 1;
	    IF b.pup.dest = maybe.pup.dest THEN {
	      PupHeader: TYPE = ARRAY [0..11) OF WORD;
	      x: LONG POINTER TO PupHeader ¬ LOOPHOLE[@b.pup.pupLength];
	      y: LONG POINTER TO PupHeader ¬ LOOPHOLE[@maybe.pup.pupLength];
	      IF x­ = y­ THEN headerMatch ¬ TRUE;
	      friends ¬ friends + 1; }; };
	  maybe ¬ maybe.next;
	  ENDLOOP; };
      nsPhonePacket => {
	maybe: Buffer.NSBuffer ¬ head;
	UNTIL maybe = NIL DO
          encap: LONG POINTER TO Encapsulation = LOOPHOLE[@maybe.encapsulation];
	  IF encap.pnType = nsPhonePacket THEN {
	    neighbors ¬ neighbors + 1;
	    IF b.ns.destination = maybe.ns.destination THEN friends ¬ friends + 1; };
	  maybe ¬ maybe.next;
	  ENDLOOP; };
      ENDCASE => NULL;  -- You get what you deserve
    RETURN[friends, neighbors, headerMatch]
    END;

  QueueOutputBuffer: INTERNAL PROCEDURE [b: Buffer.Buffer, high: BOOLEAN] =
    BEGIN
    b.network ¬ LONG[@info.network];
    info.packetsOnSendQueue ¬ info.packetsOnSendQueue + 1;
    b.next ¬ NIL;
    IF high THEN
      BEGIN
      IF info.firstHiSendBuffer = NIL THEN info.firstHiSendBuffer ¬ b
      ELSE info.lastHiSendBuffer.next ¬ b;
      info.lastHiSendBuffer ¬ b;
      END
    ELSE
      BEGIN
      IF info.firstLoSendBuffer = NIL THEN info.firstLoSendBuffer ¬ b
      ELSE info.lastLoSendBuffer.next ¬ b;
      info.lastLoSendBuffer ¬ b;
      END;
    IF info.currentSendBuffer = NIL THEN StartSending[@info];
    END;
  
  StartSending: INTERNAL PROCEDURE [line: Info] =
    BEGIN
    b: Buffer.Buffer;
    SELECT TRUE FROM
      line.firstHiSendBuffer # NIL =>
        BEGIN
        b ¬ line.firstHiSendBuffer;
        line.firstHiSendBuffer ¬ b.next;
        END;
      line.firstLoSendBuffer # NIL =>
        BEGIN
        b ¬ line.firstLoSendBuffer;
        line.firstLoSendBuffer ¬ b.next;
        END;
      ENDCASE => RETURN;
    line.currentSendBuffer ¬ b;
    IF line.encrypt THEN
      BEGIN
      words: CARDINAL ¬ b.driver.length;
      blocks: CARDINAL = (words+SIZE[DESFace.Block]-1)/SIZE[DESFace.Block];
      data: LONG POINTER = @b.encapsulation + phoneEncapsulationOffset;
      DESFace.ECBEncrypt[line.key, blocks, data, data];
      b.driver.length ¬ blocks*SIZE[DESFace.Block];  -- Round up to decrypt last block
      END;
    IF line.dlion THEN Wait[7];
    b.driver.iocb ¬ line.sendIocb;
    PhoneFace.QueueOutput[
      line.lineNumber,
      b.driver.iocb,
      @b.encapsulation + phoneEncapsulationOffset,
      2*b.driver.length];
    line.timeSendStarted ¬ System.GetClockPulses[];
    END;
    
  Wait: PROCEDURE [ms: CARDINAL] =
    BEGIN
    start: System.Pulses = System.GetClockPulses[];
    DO
      now: System.Pulses = System.GetClockPulses[];
      IF System.PulsesToMicroseconds[[now-start]] > ms*1000 THEN EXIT;
      Process.Yield[];  -- Yetch.  Pause is too crude
      ENDLOOP;
    END;

  FinishSending: PROCEDURE [line: Info, b: Buffer.Buffer] =
    BEGIN
    IF line.encrypt AND (b.allNets OR b.requeueProcedure # Buffer.ReturnBuffer) THEN
      BEGIN  -- Oops. Untrash it
      words: CARDINAL ¬ b.driver.length;
      blocks: CARDINAL = (words+SIZE[DESFace.Block]-1)/SIZE[DESFace.Block];
      data: LONG POINTER = @b.encapsulation + phoneEncapsulationOffset;
      DESFace.ECBDecrypt[line.key, blocks, data, data];
      END;
    Driver.PutOnGlobalDoneQueue[b];
    END;
    
    
  -- **************** Watcher to timeout stuck things ****************
  
  -- 2400 baud is 300 bytes/sec.  Allow 10% for slop and whatever to get 270.
  pulsesPerByte: System.Pulses = [(System.MicrosecondsToPulses[1000000]/270)+1];
  recvIdleTimeout: System.Pulses = System.MicrosecondsToPulses[30000000];
  Watcher: ENTRY PROCEDURE =
    BEGIN
    watch: CONDITION;
    Process.InitializeCondition[@watch, Process.MsecToTicks[1000]];
    UNTIL pleaseStop DO
      WAIT watch;
      FOR line: Info ¬ @info, line.next UNTIL line = NIL DO
        flap: BOOLEAN ¬ FALSE;
	now: System.Pulses = System.GetClockPulses[];
	b: Buffer.Buffer ¬ line.currentSendBuffer;
	IF PhoneFace.GetPacketsMissed[line.lineNumber] # line.missed THEN
	  BEGIN
          oldMissed: CARDINAL ¬ line.missed;
          newMissed: CARDINAL ¬ PhoneFace.GetPacketsMissed[line.lineNumber];
	  line.missed ¬ newMissed;
          StatBump[@line.stats.stats[rcvErrorNoGet], (newMissed - oldMissed)];
	  END;
        IF b # NIL AND (now - line.timeSendStarted) > pulsesPerByte*b.driver.length*2 THEN
	  BEGIN
          StatIncr[@line.stats.stats[queueTooOld]];
	  flap ¬ TRUE;
	  END;
        IF (now - line.timeLastRecv) > recvIdleTimeout THEN
	  BEGIN
          StatIncr[@line.stats.stats[tooLongSinceLastReceive]];
	  flap ¬ TRUE;
	  END;
	IF flap THEN
	  BEGIN
	  line.stats.remoteHostNumber ¬ System.nullHostNumber;
	  PhoneFace.ResetLine[line.lineNumber];
	  IF line.currentSendBuffer # NIL THEN
	    BEGIN
	    FinishSending[line, line.currentSendBuffer];
	    line.currentSendBuffer ¬ NIL;
	    END;
	  UNTIL line.firstHiSendBuffer = NIL DO
	    b: Buffer.Buffer ¬ line.firstHiSendBuffer;
	    line.firstHiSendBuffer ¬ b.next;
	    Driver.PutOnGlobalDoneQueue[b];
	    ENDLOOP;
	  UNTIL line.firstLoSendBuffer = NIL DO
	    b: Buffer.Buffer ¬ line.firstLoSendBuffer;
	    line.firstLoSendBuffer ¬ b.next;
	    Driver.PutOnGlobalDoneQueue[b];
	    ENDLOOP;
          line.packetsOnSendQueue ¬ 0;
	  FOR b: Buffer.Buffer ¬ line.firstRecvBuffer, b.next UNTIL b = NIL DO
            PhoneFace.QueueInput[
              line.lineNumber,
              b.driver.iocb,
              @b.encapsulation + phoneEncapsulationOffset,
              2*(b.driver.length - phoneEncapsulationOffset)];
	    ENDLOOP;
	  line.timeLastRecv ¬ System.GetClockPulses[];
	  END;
        ENDLOOP;
      ENDLOOP;
    END;
 
  
  -- **************** Interrupt Processing ****************
  
  Interrupt: ENTRY PROCEDURE =
    BEGIN
    Process.SetPriority[ProcessPriorities.priorityPageFaultHigh];
    UNTIL pleaseStop DO
      WAIT hardware;
      FOR line: Info ¬ @info, line.next UNTIL line = NIL DO
	DO
	  status: PhoneFace.Status;
	  b: Buffer.Buffer ¬ line.currentSendBuffer;
	  IF b = NIL THEN EXIT;
	  status ¬ PhoneFace.GetSendStatus[b.driver.iocb];
	  IF status = pending THEN EXIT;
	  IF status = ok THEN
	    BEGIN
	    bits: CARDINAL ¬ 7 + 16*b.driver.length + 16 + 7;
	    now: System.Pulses ¬ System.GetClockPulses[];
	    micro: LONG CARDINAL ¬ System.PulsesToMicroseconds[[now-line.timeSendStarted]];
	    -- ARHG!!! 4000 * 1000000 overflows a LONG CARDINAL
	    bitsPerSecond: LONG CARDINAL = ((100000*bits)/micro)*10;
	    line.bitsPerSecond ¬ (63*line.bitsPerSecond + bitsPerSecond)/64;
	    line.stats.speed ¬ Inline.LowHalf[line.bitsPerSecond/1000];
	    StatIncr[@line.stats.stats[pktsSent]];
	    StatBump[@line.stats.stats[bytesSent], 2*b.driver.length];
	    END
	  ELSE StatIncr[@line.stats.stats[sendErrorBadStatus]];
          line.packetsOnSendQueue ¬ line.packetsOnSendQueue - 1;
	  line.currentSendBuffer ¬ NIL;
	  FinishSending[line, b];
	  StartSending[line];
	  ENDLOOP;
	WHILE line.firstRecvBuffer # NIL DO
	  b: Buffer.Buffer ¬ line.firstRecvBuffer;
	  status: PhoneFace.Status ¬ PhoneFace.GetRecvStatus[b.driver.iocb];
	  newBuffer: Buffer.Buffer ¬ NIL;
	  IF status = pending THEN EXIT;
	  line.firstRecvBuffer ¬ b.next;
	  IF status # ok THEN
	    BEGIN
	    SELECT status FROM
	      overrun => StatIncr[@line.stats.stats[rcvDeviceError]];
	      packetTooLong => StatIncr[@line.stats.stats[rcvErrorDataLost]];
	      crc => StatIncr[@line.stats.stats[rcvErrorCRC]];
	      ENDCASE => StatIncr[@line.stats.stats[rcvErrorUnknown]];
	    newBuffer ¬ b;
	    b ¬ NIL;
	    END
	  ELSE
	    BEGIN
	    newBuffer ¬ Driver.GetInputBuffer[];
	    IF newBuffer = NIL THEN
	      BEGIN  -- Rats, recycle this packet
	      StatIncr[@line.stats.stats[rcvErrorNoGet]];
	      newBuffer ¬ b;
	      b ¬ NIL;
	      END
	    ELSE newBuffer.driver.iocb ¬ b.driver.iocb;
	    END;
	  IF b # NIL THEN
	    BEGIN
            encapsulation: LONG POINTER TO Encapsulation = LOOPHOLE[@b.encapsulation];
	    bytes: CARDINAL ¬ PhoneFace.GetPacketLength[b.driver.iocb];
	    b.network ¬ @line.network;
            b.driver.length ¬ bytes;
            b.driver.faceStatus ¬ unknown[101H];
	    Driver.PutOnGlobalInputQueue[b];
	    line.timeLastRecv ¬ System.GetClockPulses[];
	    StatIncr[@line.stats.stats[pktsReceived]];
	    StatBump[@line.stats.stats[bytesReceived], bytes];
	    END;
	  newBuffer.network ¬ @line.network;
          PhoneFace.QueueInput[
            line.lineNumber,
	    newBuffer.driver.iocb,
	    @newBuffer.encapsulation + phoneEncapsulationOffset,
	    2*(newBuffer.driver.length - phoneEncapsulationOffset)];
          IF line.firstRecvBuffer = NIL THEN line.firstRecvBuffer ¬ newBuffer
          ELSE line.lastRecvBuffer.next ¬ newBuffer;
	  line.lastRecvBuffer ¬ newBuffer;
	  newBuffer.next ¬ NIL;
	  ENDLOOP;
        ENDLOOP;
      ENDLOOP;
    END;
  

  -- **************** Driver Management ****************

  CreatePhone: PUBLIC PROCEDURE [host, net, lineNumber: CARDINAL, password: LONG STRING] =
    BEGIN
    line: Info;
    IF watcher = NIL THEN
      BEGIN
      [cv: hardware, mask: interruptBits] ¬ SpecialRuntime.AllocateNakedCondition[];
      Process.DisableTimeout[hardware];
      PhoneFace.TurnOn[interruptBits];  -- Also gets it STARTed
      interrupt ¬ FORK Interrupt[];
      watcher ¬ FORK Watcher[];
      line ¬ @info;
      END
    ELSE
      BEGIN
      him: LONG POINTER TO FRAME[PhoneDriver] ¬ NEW PhoneDriver;
      START him;
      him.lock ¬ @myLock;
      line ¬ @him.info;
      FOR finger: Info ¬ @info, finger.next DO
        IF finger.lineNumber = lineNumber THEN ERROR DuplicateLineNumber;
        IF finger.next = NIL THEN
	  BEGIN
	  finger.next ¬ line;
	  EXIT;
	  END;
	ENDLOOP;
      END;
    line.network.alive ¬ TRUE;
    line.lineNumber ¬ lineNumber;
    line.stats.lineNumber ¬ lineNumber;
    line.loophole.lineNumber ¬ lineNumber;
    line.network.pupHostNumber ¬ host;
    line.network.pupNetNumber ¬ net;
    SELECT TRUE FROM
      password = NIL => NULL;
      String.EqualString[password, "DLion"L] => line.dlion ¬ TRUE;
      ENDCASE =>
        BEGIN
        line.key ¬ MakeKey[password];
        line.encrypt ¬ TRUE;
        END;
    line.pool ¬ Buffer.MakePool[0, line.network.buffers];
    line.sendIocb ¬ CommUtil.AllocateIocbs[(line.network.buffers+1)*PhoneFace.controlBlockSize];
    line.recvIocbs ¬ line.sendIocb + PhoneFace.controlBlockSize;
    Driver.AddDeviceToChain[@line.network];
    END;
    
  -- Don't muck with this unless you are prepared to change both ends.
  -- This doesn't hide the string very well.
  MakeKey: PROCEDURE [source: LONG STRING] RETURNS [key: DESFace.Key] =
    BEGIN
    key ¬ DESFace.nullKey;
    FOR i: CARDINAL IN [0..source.length) DO
      j: CARDINAL = i MOD 8;
      c: CHARACTER =
        IF source[i] IN ['A..'Z] THEN 'a + (source[i] - 'A) ELSE source[i];
      key[j].b ¬ Inline.BITXOR[LOOPHOLE[c, [0..127]], key[j].b];
      ENDLOOP;
    DESFace.CorrectParity[@key];
    END;

  ActivateDriver: ENTRY PROCEDURE =
    BEGIN
    tick: CONDITION;
    Process.InitializeCondition[@tick, 1];
    PhoneFace.ResetLine[info.lineNumber];
    FOR i: CARDINAL IN [0..info.network.buffers) DO
      b: Buffer.Buffer;
      UNTIL (b ¬ Driver.GetInputBuffer[FALSE]) # NIL DO WAIT tick; ENDLOOP;
      b.driver.iocb ¬ info.recvIocbs + i*PhoneFace.controlBlockSize;
      IF info.firstRecvBuffer = NIL THEN info.firstRecvBuffer ¬ b
      ELSE info.lastRecvBuffer.next ¬ b;
      PhoneFace.QueueInput[
        info.lineNumber,
        b.driver.iocb,
        @b.encapsulation + phoneEncapsulationOffset,
        2*(b.driver.length - phoneEncapsulationOffset)];
      info.lastRecvBuffer ¬ b;
      b.next ¬ NIL;
      ENDLOOP;
    info.timeLastRecv ¬ System.GetClockPulses[];
    info.missed ¬ PhoneFace.GetPacketsMissed[info.lineNumber];
    END;

  KillDriver: PROCEDURE =
    BEGIN
    ERROR;
    END;


  -- **************** Statistics ****************

  StatIncr: PROCEDURE [counter: LONG POINTER TO LONG CARDINAL] = INLINE
    BEGIN
    counter­ ¬ counter­ + 1;
    END;

  StatBump: PROCEDURE [
    counter: LONG POINTER TO LONG CARDINAL, bumpAmount: CARDINAL] = INLINE
    BEGIN
    counter­ ¬ counter­ + bumpAmount;
    END;

  -- **************** Keep Kluger/INR happy ****************
  
  GetDriverInfo: PUBLIC PROCEDURE [lineNumber: CARDINAL]
    RETURNS [--found:-- BOOLEAN, --info:-- PhoneNetFriends.PhoneNetInfo] =
    BEGIN
    FOR finger: Info ¬ @info, finger.next UNTIL finger = NIL DO
      IF finger.network.alive AND finger.lineNumber = lineNumber THEN
        RETURN [TRUE, finger.stats];
      ENDLOOP;
    RETURN[FALSE, ];
    END;

  StatsPtrToInfo: PUBLIC PROCEDURE [statsLevel0: LONG POINTER]
    RETURNS [clientData: LONG UNSPECIFIED, lineNumber: CARDINAL] =
    -- statsLevel0 argument is from a phonenet network object
    BEGIN
    stats: LONG POINTER TO CrapForINRLoophole = LOOPHOLE[statsLevel0];
    RETURN [stats.clientData, stats.lineNumber];
    END;

  EnumerateDriverInfo: PUBLIC PROCEDURE [current: PhoneNetFriends.NetEnumerator]
    RETURNS [PhoneNetFriends.NetEnumerator, PhoneNetFriends.PhoneNetInfo] =
    BEGIN
    hisInfo: Info ¬ current;
    IF (current = PhoneNetFriends.nullNetEnumerate) AND info.network.alive THEN
      RETURN[@info, info.stats];
    IF hisInfo.next = NIL THEN RETURN [PhoneNetFriends.nullNetEnumerate, info.stats];
    RETURN [hisInfo.next, hisInfo.next.stats];
    END;
    
  END....