
DIRECTORY

Basics,
IO,
NetworkStream,
FinalizeOps USING [CallQueue, CreateCallQueue, EnableFinalization, FinalizeProc],
RefText USING [ObtainScratch, ReleaseScratch],
Rope USING [ROPE],
SunRPCAuth USING [Authenticate, AuthenticateResult, CheckReplyVerifier, Conversation, Flavor, maxValueBytes, nullFlavor],
SunRPCNumbers USING [],
SunRPC,
SunRPCOnNetworkStream,
SunRPCType USING [AcceptStat, AuthStat, MsgType, RejectStat, ReplyStat, rpcVersion]
;

SunRPCOnNetworkStreamImpl: CEDAR MONITOR
LOCKS sd USING sd: StreamServer
IMPORTS IO, NetworkStream, Basics, FinalizeOps, RefText, SunRPC, SunRPCAuth
EXPORTS SunRPCOnNetworkStream
~ {
OPEN RPCT: SunRPCType;
ROPE: TYPE ~ Rope.ROPE;

UnsafeBlock: TYPE ~ Basics.UnsafeBlock;

Handle: TYPE ~ SunRPC.Handle;
Object: TYPE ~ SunRPC.Object;

StreamData: TYPE ~ REF StreamDataObject;
StreamDataObject: TYPE ~ RECORD [
in, out: IO.STREAM,
protocolFamily: ATOM Ź NIL,
remote: Rope.ROPE Ź NIL,
sendBuf: REF TEXT,
inLim: CARDINAL Ź 0,
index: CARDINAL Ź 0,
endOfRec: BOOL
];


Conversation: TYPE ~ SunRPCAuth.Conversation;
AuthFlavor: TYPE ~ SunRPCAuth.Flavor;
nullFlavor: AuthFlavor ~ SunRPCAuth.nullFlavor;
AuthValue: TYPE ~ REF TEXT;

Error: ERROR[code: ATOM] ~ SunRPC.Error;
networkStreamFlavor: ATOM ~ $networkStream;

dataBufBytes: CARDINAL ~ 8704;

maxAuthBytes: CARDINAL ~ SunRPCAuth.maxValueBytes;
maxRefTextLength: CARDINAL Ź 8*1024;
maxUnsafeBlockLength: CARDINAL Ź CARDINAL.LAST - 3;	-- ensures stopIndexPlusOne fields won't overflow in calls to ByteBlt


TextPtrFromRefText: UNSAFE PROC [block: REF READONLY TEXT] RETURNS [LONG POINTER] ~ TRUSTED INLINE {
RETURN[ LOOPHOLE[block, LONG POINTER] + UNITS[TEXT[0]] ] };

Create: PUBLIC PROC [protocolFamily: ATOM, remote: ROPE] RETURNS [h: Handle]
~ {
d: StreamData;
h Ź NEW[Object];
h.flavor Ź networkStreamFlavor;
h.flavorData Ź d Ź NEW[StreamDataObject];
h.procs Ź streamProcs;
d.sendBuf Ź RefText.ObtainScratch[dataBufBytes];
d.sendBuf.length Ź BYTES[Basics.FWORD];
d.endOfRec Ź TRUE; -- no incoming data;
{
ENABLE NetworkStream.Error, IO.Error => Error[$unreachable];
[d.in, d.out] Ź NetworkStream.CreateStreams[protocolFamily~protocolFamily, remote~remote, transportClass~$basicStream ];
};
d.protocolFamily Ź protocolFamily;
d.remote Ź remote;
[] Ź FinalizeOps.EnableFinalization[h, fQueue];
};

GetRemote: PUBLIC PROC [h: Handle] RETURNS [protocolFamily: ATOM, remote: ROPE]
~ {
d: StreamData Ź NARROW[h.flavorData];
protocolFamily Ź d.protocolFamily;
remote Ź d.remote;
};

Destroy: PUBLIC PROC [h: Handle] ~ {
WITH h.flavorData SELECT FROM
d: StreamData => {  
Shutdown[d];
d.in Ź d.out Ź NIL;
};
ENDCASE;
};

Shutdown: PROC [d: StreamData] ~ {
IF d.in # NIL THEN { d.in.Close[abort~TRUE] };
IF d.out # NIL THEN { d.out.Close[abort~TRUE] };
};
streamProcs: REF SunRPC.ProcsObject ~ NEW[ SunRPC.ProcsObject Ź [
destroy~Destroy,
sendCallAndReceiveReply~SendCallAndReceiveReply,
receiveAnotherReply~ReceiveAnotherReply,
releaseReply~ReleaseReply,
bytesRemaining~CantGetBytesRemaining,
getByte~GetByte,
getAlign~GetAlign,
getH~GetH,
getF~GetF,
unsafeGetBlock~UnsafeGetBlock,
getBlock~GetBlock,
putByte~PutByte,
putAlign~PutAlign,
putH~PutH,
putF~PutF,
unsafePutBlock~UnsafePutBlock, 
putBlock~PutBlock,
prepareForMessage~PrepareForMessage
]];

SendCallAndReceiveReply: PROC [h: Handle, timeoutMsec: CARDŹCARD.LAST, retries: CARDŹ0] ~ {
SendAndReceive[h, TRUE];
};

ReceiveAnotherReply: PROC [h: Handle, timeoutMsec: CARDŹCARD.LAST] ~ {
SendAndReceive[h, FALSE];
};

SendAndReceive: PROC [h: Handle, doSend: BOOL] ~ {
errorCode: ATOM Ź NIL;
replyVerifier: AuthValue;
IF doSend THEN {
SendSeg[h, TRUE];
};
SkipRec[h];
{
{ ENABLE Error => { 
SELECT code FROM 
$unreachable => errorCode Ź $unreachable;
ENDCASE => errorCode Ź $protocolError; 
GOTO Done 
};
returnedXid, returnedMsgType: CARD32;
returnedXid Ź SunRPC.GetCard32[h];
returnedMsgType Ź SunRPC.GetCard32[h];
IF (returnedXid # h.xid) OR (returnedMsgType # ORD[RPCT.MsgType.reply]) THEN { errorCode Ź $protocolError; GOTO Done } -- out of synch;
};
{ ENABLE Error => { errorCode Ź $protocolError; GOTO Done };
replyStat, acceptStat, rejectStat, authStat: CARD32;
replyFlavor: AuthFlavor;
SELECT (replyStat Ź SunRPC.GetCard32[h]) FROM
ORD[RPCT.ReplyStat.msgAccepted] => {
[replyFlavor, replyVerifier] Ź SunRPC.GetAuth[h];
errorCode Ź SELECT SunRPCAuth.CheckReplyVerifier[NARROW[h.authData], replyFlavor, replyVerifier] FROM
ok => NIL,
badVerifier => $badReplyVerifier,
wrongVerifier => $wrongReplyVerifier, 
ENDCASE => ERROR Error [$bugSendAndReceive];
IF errorCode # NIL THEN GOTO Done;
acceptStat Ź SunRPC.GetCard32[h];
errorCode Ź SELECT acceptStat FROM
ORD[RPCT.AcceptStat.success] => NIL, -- winner!
ORD[RPCT.AcceptStat.progUnavail] => $wrongProgram,
ORD[RPCT.AcceptStat.progMismatch] => $wrongProgramVersion,
ORD[RPCT.AcceptStat.procUnavail] => $wrongProc,
ENDCASE => $protocolError;
GOTO Done;
};
ORD[RPCT.ReplyStat.msgDenied] => {
SELECT (rejectStat Ź SunRPC.GetCard32[h]) FROM
ORD[RPCT.RejectStat.rpcMismatch] => {
errorCode Ź $wrongRPCVersion;
};
ORD[RPCT.RejectStat.authError] => {
authStat Ź SunRPC.GetCard32[h];
errorCode Ź SELECT authStat FROM
ORD[RPCT.AuthStat.authBadcred] => $badCredentials,
ORD[RPCT.AuthStat.authRejectedcred] => $wrongCredentials,
ORD[RPCT.AuthStat.authBadverf] => $badVerifier,
ORD[RPCT.AuthStat.authRejectedverf] => $wrongVerifier,
ORD[RPCT.AuthStat.authTooweak] => $weakCredentials,
ENDCASE => $protocolError;
};
ENDCASE => {
errorCode Ź $protocolError
};
GOTO Done;
};
ENDCASE => {
errorCode Ź $protocolError;
GOTO Done;
};
};
EXITS
Done => NULL;
};
IF replyVerifier # NIL
THEN { RefText.ReleaseScratch[replyVerifier]; replyVerifier Ź NIL };
IF errorCode # NIL THEN { ERROR Error[errorCode] };
};

ReleaseReply: PROC [h: Handle] ~ {
h.authData Ź NIL; -- help finalization
};

CantGetBytesRemaining: PROC [h: Handle] RETURNS [bytes: CARDINAL] ~ {
Error[$wrongFlavor];
};


Server: TYPE ~ SunRPC.Server;
ServerObject: TYPE ~ SunRPC.ServerObject;

StreamServer: TYPE ~ REF StreamServerObject;
StreamServerObject: TYPE ~ MONITORED RECORD [
listener: NetworkStream.Listener
];

myServerMgtProcs: SunRPC.ServerMgtProcs ~ NEW[SunRPC.ServerMgtProcsObject Ź [
destroyServer~DestroyServer
]];

CreateServer: PUBLIC PROC [pgm, version: CARD, serverProc: SunRPCOnNetworkStream.ServerProc, protocolFamily: ATOM, local: ROPE Ź NIL, clientData: REF] RETURNS [s: Server]
~ {
sd: StreamServer ~ NEW[StreamServerObject];
s Ź NEW[ServerObject];
s.flavor Ź networkStreamFlavor;
s.flavorData Ź sd;
s.pgm Ź pgm;
s.version Ź version;
s.serverProc Ź serverProc;
createdServers Ź createdServers.SUCC;
s.clientData Ź clientData;
sd.listener Ź NetworkStream.CreateListener[protocolFamily~protocolFamily, local~local, transportClass~$basicStream, listenerWorkerProc~Serve, listenerWorkerClientData~s];
[] Ź FinalizeOps.EnableFinalization[s, fQueue];
};

GetServerAddress: PUBLIC PROC [s: Server] RETURNS [protocolFamily: ATOM, local: ROPE ] ~ {
sN: Server ~ IF s.flavor=networkStreamFlavor THEN s ELSE Error[$wrongFlavor];
sd: StreamServer ~ NARROW[s.flavorData];
[protocolFamily~protocolFamily, local~local] Ź NetworkStream.GetListenerInfo[sd.listener];
};

DestroyServer: PROC [s: Server] ~ {
sd: StreamServer ~ NARROW[s.flavorData];
LockedDestroyServer: ENTRY PROC [sd: StreamServer] ~ {
IF NOT s.dead THEN destroyedServers Ź destroyedServers.SUCC;
NetworkStream.DestroyListener[sd.listener]; 
sd.listener Ź NIL;
s.dead Ź TRUE;
};
LockedDestroyServer[sd];
};
createdServers: CARD Ź 0;
droppedServers: CARD Ź 0;
destroyedServers: CARD Ź 0;
finishedServers: CARD Ź 0;

FinalizeServer: PROC [s: Server] = {
IF NOT s.dead
THEN { -- Can't happen unless the daemons have failed for some reason ...
droppedServers Ź droppedServers.SUCC;
[] Ź FinalizeOps.EnableFinalization[s, fQueue];
DestroyServer[s];
}
ELSE { -- Normal end of life
finishedServers Ź finishedServers.SUCC;
};
};

Serve: NetworkStream.ListenerWorkerProc ~  {
s: Server Ź NARROW[NetworkStream.GetListenerInfo[listener].clientData];
sd: StreamServer ~ NARROW[s.flavorData];
h: Handle;
d: StreamData;
stillServing: BOOL Ź TRUE;
h Ź NEW[Object];
h.flavor Ź networkStreamFlavor;
h.flavorData Ź d Ź NEW[StreamDataObject];
h.procs Ź streamProcs;
d.sendBuf Ź RefText.ObtainScratch[dataBufBytes];
d.sendBuf.length Ź BYTES[Basics.FWORD];
d.in Ź in;
d.out Ź out;
WHILE stillServing AND NOT s.dead DO 
ENABLE { 
IO.Error, IO.EndOfStream => {
stillServing Ź FALSE;
LOOP;
};
Error => {
SELECT code FROM
$unreachable => stillServing Ź FALSE;
ENDCASE => SkipRec[h];
LOOP; 
};
};
msgType: CARD32;
h.xid Ź SunRPC.GetCard32[h];
IF s.dead THEN LOOP;
msgType Ź SunRPC.GetCard32[h];
SELECT TRUE FROM
(msgType # ORD[RPCT.MsgType.call]) => {
Error[$protocolError];
};
ENDCASE => {
CallServerProcAndSendReply[s, h];
};
ENDLOOP;
Shutdown[d];
};

CallServerProcAndSendReply: PROC [s: Server, h: Handle] ~ {
errorCode: ATOM;
credentials, verifier: AuthValue;
sendReply: BOOL Ź TRUE;
BEGIN
{ ENABLE Error => { sendReply Ź FALSE; GOTO Out };
rpcvers, prog, vers, proc: CARD32;
cFlavor, vFlavor: AuthFlavor;
authResult: SunRPCAuth.AuthenticateResult;
conversation: Conversation;

rpcvers Ź SunRPC.GetCard32[h];
IF (rpcvers # RPCT.rpcVersion)
THEN { errorCode Ź $wrongRPCVersion; GOTO Reply };
prog Ź SunRPC.GetCard32[h];
vers Ź SunRPC.GetCard32[h];
proc Ź SunRPC.GetCard32[h];
[cFlavor, credentials] Ź SunRPC.GetAuth[h
! Error => { errorCode Ź $badCredentials; GOTO Reply }];
[vFlavor, verifier] Ź SunRPC.GetAuth[h
! Error => { errorCode Ź $badVerifier; GOTO Reply }];
[authResult, h.authFlavor, h.authData, conversation] Ź SunRPCAuth.Authenticate[cFlavor, credentials, vFlavor, verifier];
IF authResult # ok THEN {
errorCode Ź SELECT authResult FROM
badCredentials => $badCredentials,
wrongCredentials => $wrongCredentials,
badVerifier => $badVerifier,
wrongVerifier => $wrongVerifier,
ENDCASE => ERROR Error [$bugCallServerProcAndSendReply1];
GOTO Reply;
};
IF prog # s.pgm
THEN { errorCode Ź $wrongProgram; GOTO Reply };
IF vers # s.version
THEN { errorCode Ź $wrongProgramVersion; GOTO Reply };
[doReply~sendReply] Ź s.serverProc[h, conversation, proc, s.clientData
! Error => { errorCode Ź code; CONTINUE }];
EXITS
Reply => NULL;
};


{ ENABLE Error => ERROR Error [$bugCallServerProcAndSendReply2]; -- bug
SELECT errorCode FROM
NIL => NULL;
$wrongRPCVersion => {
SunRPC.StartRejectReply[h, ORD[RPCT.RejectStat.rpcMismatch]];
SunRPC.PutCard32[h, RPCT.rpcVersion];
SunRPC.PutCard32[h, RPCT.rpcVersion];
};
$badCredentials => {
SunRPC.StartRejectReply[h, ORD[RPCT.RejectStat.authError]];
SunRPC.PutCard32[h, ORD[RPCT.AuthStat.authBadcred]];
};
$wrongCredentials => {
SunRPC.StartRejectReply[h, ORD[RPCT.RejectStat.authError]];
SunRPC.PutCard32[h, ORD[RPCT.AuthStat.authRejectedcred]];
};
$badVerifier => {
SunRPC.StartRejectReply[h, ORD[RPCT.RejectStat.authError]];
SunRPC.PutCard32[h, ORD[RPCT.AuthStat.authBadverf]];
};
$wrongVerifier => {
SunRPC.StartRejectReply[h, ORD[RPCT.RejectStat.authError]];
SunRPC.PutCard32[h, ORD[RPCT.AuthStat.authRejectedverf]];
};
$weakCredentials => {
SunRPC.StartRejectReply[h, ORD[RPCT.RejectStat.authError]];
SunRPC.PutCard32[h, ORD[RPCT.AuthStat.authTooweak]];
};
$wrongProgram => {
SunRPC.StartAcceptReply[h, ORD[RPCT.AcceptStat.progUnavail]];
};
$wrongProgramVersion => {
SunRPC.StartAcceptReply[h, ORD[RPCT.AcceptStat.progMismatch]];
SunRPC.PutCard32[h, s.version];
SunRPC.PutCard32[h, s.version];
};
$wrongProc => {
SunRPC.StartAcceptReply[h, ORD[RPCT.AcceptStat.procUnavail]];
};
$abortWithoutReturn, $unreachable => {
sendReply Ź FALSE;
};
ENDCASE => {
SunRPC.StartAcceptReply[h, ORD[RPCT.AcceptStat.garbageArgs]];
};
};
EXITS
Out => NULL;
END;

IF sendReply
THEN -- send the reply -- {
SendSeg[h, TRUE];
};

SkipRec[h]; -- consume any remaining bytes of this call
h.authData Ź NIL; -- help finalization
IF credentials # NIL THEN { RefText.ReleaseScratch[credentials]; credentials Ź NIL };
IF verifier # NIL THEN { RefText.ReleaseScratch[verifier]; verifier Ź NIL };
};
Refill: PROC [h: Handle] ~ {
ENABLE IO.Error, IO.EndOfStream => { Shutdown[NARROW[h.flavorData]]; Error[$unreachable]; };
d: StreamData Ź NARROW[h.flavorData];

segSize: CARD Ź 0;
IF d.index # d.inLim THEN ERROR Error [$bugRefill]; -- bug

WHILE d.index = d.inLim DO
IF d.endOfRec THEN Error[$outOfData];
segSize Ź Basics.Card32FromF[d.in.GetFWord[]];
d.endOfRec Ź segSize >= 80000000H;
segSize Ź Basics.BITAND[segSize, 7FFFFFFFH];
IF segSize > 64*1024 THEN ERROR Error [$bugRefill]; -- bug
d.inLim Ź segSize;
d.index Ź 0;
ENDLOOP;
};

SkipRec: PROC [h: Handle]  ~ {
d: StreamData Ź NARROW[h.flavorData];
WHILE NOT d.endOfRec DO
SkipSeg[h];
Refill[h];
ENDLOOP;
SkipSeg[h];
d.endOfRec Ź FALSE;
};

maxSkipBuf: CARD ~ 1024;

SkipSeg: PROC [h: Handle] ~ TRUSTED {
d: StreamData Ź NARROW[h.flavorData];
WHILE d.inLim - d.index # 0 DO
skipSize: INTEGER Ź MIN[d.inLim - d.index, maxSkipBuf];
skipBuf: ARRAY [0..maxSkipBuf) OF CHAR;
skipped: INT Ź d.in.UnsafeGetBlock[[base~LOOPHOLE[@skipBuf], startIndex~0, count~skipSize]];
d.index Ź d.index+skipped;
ENDLOOP;
};

GetByte: PROC [h: Handle] RETURNS [byte: BYTE] ~ {
d: StreamData Ź NARROW[h.flavorData];
IF (d.index+BYTES[BYTE]) > d.inLim THEN Refill[h];
byte Ź d.in.GetByte[];
d.index Ź d.index+BYTES[BYTE];
};

GetH: PROC [h: Handle] RETURNS [hword: Basics.HWORD] ~ {
d: StreamData Ź NARROW[h.flavorData];
IF (d.index+BYTES[Basics.HWORD]) > d.inLim THEN {
hword.hi Ź GetByte[h];
hword.lo Ź GetByte[h];
}
ELSE {
hword Ź d.in.GetHWord[];
d.index Ź d.index+BYTES[Basics.HWORD];
};
};

GetF: PROC [h: Handle] RETURNS [fword: Basics.FWORD] ~ {
d: StreamData Ź NARROW[h.flavorData];
IF (d.index+BYTES[Basics.FWORD]) > d.inLim THEN {
fword.hi.hi Ź GetByte[h];
fword.hi.lo Ź GetByte[h];
fword.lo.hi Ź GetByte[h];
fword.lo.lo Ź GetByte[h];
}
ELSE { 
fword Ź d.in.GetFWord[];
d.index Ź d.index+BYTES[Basics.FWORD];
};
};

UnsafeGetBlock: UNSAFE PROC [h: Handle, block: UnsafeBlock]
~ UNCHECKED {
delta: INT Ź block.startIndex / BYTES[WORD]; -- delta is in WORDs
block.base Ź block.base + delta*UNITS[WORD]; -- base is in UNITs
block.startIndex Ź (block.startIndex - delta*BYTES[WORD]); -- index is in BYTEs
IF (CARD[block.count] > maxUnsafeBlockLength) THEN ERROR Error[$outOfData];
UnsafeGetBlockInner[h, block];
};

UnsafeGetBlockInner: UNSAFE PROC [h: Handle, block: UnsafeBlock]
~ UNCHECKED {
d: StreamData Ź NARROW[h.flavorData];
bytesMoved: INT Ź 0;
WHILE bytesMoved < block.count DO
IF d.inLim-d.index = 0 THEN Refill[h];
{
try: CARD Ź MIN[block.count-bytesMoved, d.inLim-d.index];
got: CARD Ź d.in.UnsafeGetBlock[[base~block.base, startIndex~block.startIndex+bytesMoved, count~try]];
IF got#try THEN Error[$outOfData];
bytesMoved Ź bytesMoved+got;
d.index Ź d.index + got;
};
ENDLOOP;
};

GetBlock: PROC [h: Handle, block: REF TEXT, startIndex, count: CARDINAL] ~ {
IF startIndex > block.length THEN ERROR Error [$badStart];
count Ź MIN[count, block.maxLength-startIndex];
TRUSTED {
UnsafeGetBlockInner[h,
[base~TextPtrFromRefText[block], startIndex~startIndex, count~count]];
};
block.length Ź startIndex + count;
};

GetAlign: PROC [h: Handle] ~ {
d: StreamData Ź NARROW[h.flavorData];
WHILE (d.index MOD 4) # 0 DO [] Ź GetByte[h]; ENDLOOP;
};

PutByte: PROC [h: Handle, byte: BYTE] ~ {
d: StreamData Ź NARROW[h.flavorData];
dB: REF TEXT ~ d.sendBuf;
index: CARDINAL Ź MakeRoom[h, BYTES[BYTE]];
dB.length Ź index + BYTES[BYTE];
dB[index] Ź VAL[byte];
};

PutH: PROC [h: Handle, hword: Basics.HWORD] ~ {
d: StreamData Ź NARROW[h.flavorData];
dB: REF TEXT ~ d.sendBuf;
index: CARDINAL Ź MakeRoom[h, BYTES[Basics.HWORD]];
dB.length Ź index + BYTES[Basics.HWORD];
dB[index] Ź VAL[hword.hi];
dB[index+1] Ź VAL[hword.lo];
};

PutF: PROC [h: Handle, fword: Basics.FWORD] ~ {
d: StreamData Ź NARROW[h.flavorData];
dB: REF TEXT ~ d.sendBuf;
index: CARDINAL Ź MakeRoom[h, BYTES[Basics.FWORD]];
dB.length Ź index + BYTES[Basics.FWORD];
dB[index] Ź VAL[fword.hi.hi];
dB[index+1] Ź VAL[fword.hi.lo];
dB[index+2] Ź VAL[fword.lo.hi];
dB[index+3] Ź VAL[fword.lo.lo];
};

MakeRoom: PROC [h: Handle, size: CARDINAL] RETURNS [index: CARDINAL] ~ {
d: StreamData Ź NARROW[h.flavorData];
IF (d.sendBuf.length + size) > d.sendBuf.maxLength THEN {
SendSeg[h, FALSE];
};
index Ź d.sendBuf.length;
};

SendSeg: PROC [h: Handle, endOfRec: BOOL] ~ {
d: StreamData Ź NARROW[h.flavorData];
dB: REF TEXT ~ d.sendBuf;
length: Basics.FWORD Ź Basics.FFromCard32[dB.length - BYTES[Basics.FWORD]];
IF endOfRec THEN length.hi.hi Ź length.hi.hi+80H;
dB[0] Ź VAL[length.hi.hi];
dB[1] Ź VAL[length.hi.lo];
dB[2] Ź VAL[length.lo.hi];
dB[3] Ź VAL[length.lo.lo];
{
ENABLE IO.Error => { Shutdown[d]; Error[$unreachable] };
d.out.PutBlock[dB];
dB.length Ź BYTES[Basics.FWORD];
IF endOfRec THEN NetworkStream.SendSoon[d.out];
};
};

UnsafePutBlock: UNSAFE PROC [h: Handle, block: UnsafeBlock]
~ {
d: StreamData Ź NARROW[h.flavorData];
dB: REF TEXT ~ d.sendBuf;
bytesMoved: INT Ź 0;
TRUSTED {
delta: INT Ź block.startIndex / BYTES[WORD]; -- delta in WORDs
block.base Ź block.base + delta*UNITS[WORD]; -- base in UNITs
block.startIndex Ź (block.startIndex - delta*BYTES[WORD]); -- index in BYTEs
};
SELECT CARD[block.count] FROM
0 => RETURN;
> maxUnsafeBlockLength => ERROR Error[$outOfBufferSpace];
ENDCASE;
WHILE bytesMoved < block.count DO TRUSTED
{
thisTime: INT Ź Basics.ByteBlt[
to~[TextPtrFromRefText[dB], dB.length, dB.maxLength], from~[block.base, block.startIndex+bytesMoved, block.startIndex+block.count]];
bytesMoved Ź bytesMoved+thisTime;
dB.length Ź dB.length + thisTime;
IF dB.length = dB.maxLength THEN SendSeg[h, FALSE];
};
ENDLOOP;
};

PutBlock: PROC [h: Handle, block: REF READONLY TEXT, startIndex: CARDINAL Ź 0, count: CARDINAL] ~ TRUSTED {
IF startIndex > block.length THEN ERROR Error[$badStart];
count Ź MIN[count, block.length-startIndex];
UnsafePutBlock[h, [base~TextPtrFromRefText[block], startIndex~startIndex, count~count]];
};

PutAlign: PROC [h: Handle, padValue: BYTE] ~ {
d: StreamData Ź NARROW[h.flavorData];
dB: REF TEXT ~ d.sendBuf;
WHILE (dB.length MOD 4) # 0 DO
PutByte[h, padValue];
ENDLOOP;
};

PrepareForMessage: PROC [h: Handle] ~ {
};

fQueue: FinalizeOps.CallQueue Ź FinalizeOps.CreateCallQueue[Finalizer];
Finalizer: FinalizeOps.FinalizeProc = {
WITH object SELECT FROM
h: Handle => Destroy[h];
s: Server => FinalizeServer[s];
ENDCASE;
};
}...

   Ü  
SunRPCOnNetworkStreamImpl.mesa
Copyright Ó 1989, 1992 by Xerox Corporation.  All rights reserved.
Demers, November 23, 1988 2:45:39 pm PST
Carl Hauser, November 22, 1988 4:01:56 pm PST
Willie-Sue, March 16, 1989 7:03:43 pm PST
Michael Plass, December 30, 1991 11:21 am PST
David Nichols, January 15, 1991 5:44 pm PST
Chauser, January 14, 1992 1:51 pm PST
Russ Atkinson (RRA) July 20, 1993 7:32 pm PDT
Christian Jacobi, July 24, 1992 2:29 pm PDT
Doug Terry, July 30, 1993 10:10 am PDT
Types
Parameters
LOOPHOLEs
Client Handles
Class procs
Is it a reply message for this call?
At this point, committed to accepting the reply message.  Parse it, switching on replyStat ...
Server Registration
Server Finalization
Statistics
finalization is probably useless for these servers
Servers
PROC [listener: Listener, in: STREAM, out: STREAM];
nb: it's not clear from the NetworkStream interface whether this is called in a forked process or not; ajd says it is.
nb: this architecture binds the rpc program to the listener and hence to the session existing here.  Alternatively, we could allows calls to different programs to be intermixed on a single pair of streams.  Ajd says the latter appeals to his biases, but the former is closer to what Sun's rpc on tcp servers do.
Aquire handle for the session ...
Check RPC version (else we can't parse the message)
Get <prog, vers, proc>.  There's nothing we can do with them yet, until we've examined the credentials and verifier, but that's the way they defined the protocol.
Get credentials ...
Get verifier ...
Authenticate ...
Check program, version ...
Call the server proc!
Serializing / Deserializing
When this returns there must be at least 1 byte in the current segment for GetByte to work.
Finalization
 Ęö  (cedarcode) styleNewlineDelimiter
 codeK
Ďe7BK(K-K)K-K+K%K-K+K&K Ďk		K KKKK@QK!.KKiyKKKKCSKK Ďn(KKDKKKKheadKK K'K KKK K(!K	KKK	KKK
KK K K-%K//KK K(
K+K KK K2K
$KĎcEyK K 		dK	;K 
LKKK	KK)KK0K'K 'K<KxKK"KK/KK 	
OKK%K"KKK $KKKKKK "K.K	0KAKK00K((KK%%KKK

K

KKKKK

K

KKK#KK [KKK FKKK 2KKKKKK$K)K 'K
KK%K"K&K KK^^(<K-4K#-$K1*eK
K!!K&&K,K"K!"K 
/K*2K2:K'/KK
K"$.%KK#K
 K*2K19K'/K.6K+3KKKKK
KKK
KKKKK:DK3KK "K &KK 	EKKK K KK)K K,	-K  KK * MKKK @	ŞKK+KKKKKKK %KKŞK/KK 	ZKMK(KZKK #K(6K%<K,,KK	KKK
KKKKK $K2K BIK %K/KK K"'KKK ',K3K5GK(K

KKKvKˇ!K	KK)KK0K'K
K%	KKK

K%KKKKK	KKK'KKK!!KKKKK ;KK!!K2K"KK*KK 3KK!	2˘KKKKT
bKN
\Kx"K""K&&KK  K)9KKK	/K%	6KfrK	KK K 
* GKK=K%K%KK;K4KK;K9KK;K4KK;K9KK;K4KK=KK>KKKK=K&KKK=KKKKK 
 KKK K +7K &K6UK0LKK[K(\%K K	K :K K%K.K"K,K :KKKKK K%KK
KKKKK KK %K%K
 7K	'K	+\KKKK 2K%K
2KKKK 8K%
1KKKKK&KKK 8K%
1KKKKKKK&KKK  ;K	K AK  @K- OK%KKKK @K	K%K!K&K*9K]fK	"KKKKKK 
LK:K$/	K]]KK"KK K%K
6KK )K%KK+K KKK /K%KK3K(KKKK /K%KK3K(KKKKKK 
	HK%19KKKKK -K%KK"KK
!1KKKKK/8KK K
/KKK  ;KK%KK	K >K  =K- LKKK9K)K
¤K!K!K3KKKK kK9K!,KXXKK .K%KKKKK 'KK KG	'KKKKKK      G  eî  