;Alto->8086 small-c compiler rev 2.0
C_CODE SEGMENT

$INCLUDE(8086LIB.D)

$INCLUDE(rpcpktstreams.DEC)

ASSUME CS:C_CODE, DS:C_DATA

; #include <Queue.h>

; extern struct ExportInstance exportTable[1];

; extern int used;	/* # current exports */

; extern struct PktConversationID *firstConversation;

; extern int GetConnectionState();

; extern int IdleReceive();

; extern struct Queue *myCtxQ;

; extern union Machine myHost;

; extern int *mySoc;

; extern int PktExchange();

; extern int rpct;

; extern int CallFailed;

; extern int CONT();

; extern int RejectUnbound;

; extern int RejectProtocol;

; extern SendPup();

; extern struct PBI *GetPBI();

; extern int DoubleEq();

; extern int MultEq();

; extern CurrentContext();

; extern Block();

; extern Enqueue();

; extern int *Unqueue();

; extern int DoubleComp();

; extern int DoubleDiff();

; extern int DoubleInc();

; extern Move2();

; extern int StringSize();

; extern int *GetFixed();

; extern MoveBlock();

; extern Zero();

; extern int apply();

; static int idlerAckCount;

; static int idlerRequeueCount;

; int MisusedConversation;

; struct ConnectionData {

;   struct ConnectionData *next;

;   struct ConnectionID id;

;   struct CallCount callCt;

;   struct ConversationObject *conv; };

; struct ConnectionData *connections[0];

; struct CalleeState {

;   struct CalleeState *next;

;   num callee;	/* PSB.PSBIndex */

;   struct Header *state; };

; struct Queue callees; /* pointer to CalleeState */

; int lastCallDest[0];	/* ARRAY {0..maxPSB;}; OF PSB */

; static RecordCallDest(header) struct Header *header;{ lastCallDest[header->destPSB] = header->srcePSB; };
_RecordCallDest:
PUSH BP
MOV BP,SP
PUSH BX

;	BX _ _header
POP BX
PUSH BX
MOV CX,[BX+4]
MOV BX,_lastCallDest
SAL CX
ADD BX,CX

;	CX _ _header
POP CX
PUSH CX
MOV DI,CX
MOV CX,[DI+6]
MOV [BX],CX
MOV SP,BP
POP BP
RET;

; StartCall(callPkt, interface, localConversation)
_StartCall:

; 	struct PBI *callPkt;

; 	struct ImportInstance *interface;

; 	struct Conversation *localConversation; {
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   int myPSB;

;   struct Header *header;

;   struct RPCCtx *CtxRunning;
ADD SP,0FFFAX

;   CtxRunning = CurrentContext();
CALL _CurrentContext

;	_CtxRunning _ BX
POP DX
PUSH BX

;   myPSB = CtxRunning->user.myPSB;

;	BX _ _CtxRunning
POP BX
PUSH BX
MOV CX,[BX+26]

;	_myPSB _ CX
MOV [BP-6],CX

;   header = callPkt->pup;

;	BX _ _callPkt
MOV BX,[BP+4]
MOV CX,[BX+6]

;	_header _ CX
MOV [BP-8],CX

;   header->destHost = interface->host;

;	BX _ _header
MOV BX,[BP-8]

;	DI _ _interface
MOV DI,[BP-2]
MOV CX,[DI]
MOV [BX+8],CX

;   header->destSoc.LS = rpcSocket;

;	BX _ _header
MOV BX,[BP-8]
MOV BYTE PTR [BX+13],01EX

;   header->destPSB = lastCallDest[myPSB];

;	BX _ _header
MOV BX,[BP-8]

;	CX _ _myPSB
MOV CX,[BP-6]
MOV AX,_lastCallDest
SAL CX
ADD CX,AX
MOV DI,CX
MOV CX,[DI]
MOV [BX+4],CX

;   callPkt->convHandle = localConversation;

;	BX _ _callPkt
MOV BX,[BP+4]

;	CX _ _localConversation
MOV CX,[BP-4]
MOV [BX+4],CX

;   if (localConversation == unencrypted)

;	BX _ _localConversation
MOV BX,[BP-4]
OR BX,BX
JNZ X1

;   	Move2(&header->conv, firstConversation);

;	BX _ _header
MOV BX,[BP-8]
ADD BX,014X
PUSH BX
MOV BX,_firstConversation
POP CX
CALL _Move2

;   else {
JR X2
X1:

;     Move2(&header->conv, &localConversation->id.count);

;	BX _ _header
MOV BX,[BP-8]
ADD BX,014X

;	CX _ _localConversation
MOV CX,[BP-4]
ADD CX,4
XCHG BX,CX
CALL _Move2

;     if (localConversation->id.originator.w == myHost.w)

;	BX _ _localConversation
MOV BX,[BP-4]
MOV CX,[BX+2]
MOV BX,WORD PTR _myHost
CMP CX,BX
JNZ X3

;     	header->conv.fields &= notCalleeMask; /* header->conv.originator = caller */

;	BX _ _header
MOV BX,[BP-8]
AND WORD PTR [BX+22],0FF7FX

;     else if (header->destHost.w == localConversation->id.originator.w)
JR X4
X3:

;	BX _ _header
MOV BX,[BP-8]
MOV CX,[BX+8]

;	BX _ _localConversation
MOV BX,[BP-4]
MOV AX,[BX+2]
CMP CX,AX
JNZ X5

;     	header->conv.fields |= calleeField; /* header->conv.originator = callee */

;	BX _ _header
MOV BX,[BP-8]
OR WORD PTR [BX+22],080X

;     else ERROR(MisusedConversation); };
JR X6
X5:
X6:
X4:
X2:

;   header->pktID.activity = myPSB;

;	BX _ _header
MOV BX,[BP-8]

;	CX _ _myPSB
MOV CX,[BP-6]
MOV [BX+24],CX

;   header->pktID.pktSeq = 0; /* => new call -- */

;	BX _ _header
MOV BX,[BP-8]
MOV WORD PTR [BX+30],0

;   MoveBlock(&header->callSpec.dispatcherDet, &interface->dispatcherDet, lenDispatcherDetails);

;	BX _ _header
MOV BX,[BP-8]
ADD BX,020X
PUSH BX

;	BX _ _interface
MOV BX,[BP-2]
ADD BX,4
PUSH BX
MOV BX,4
POP CX
CALL _MoveBlock
POP DX

;   Block(); };
CALL _Block
MOV SP,BP
POP BP
RET;

; int/* returnLength: */

; Call(pkt, callLength, maxReturnLength)
_Call:

; 	struct PBI *pkt; int callLength, maxReturnLength; {
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   int returnLength;

;   struct Header *recvdHeader;
ADD SP,0FFFCX

;   recvdHeader = pkt->pup;

;	BX _ _pkt
MOV BX,[BP+4]
MOV CX,[BX+6]

;	_recvdHeader _ CX
POP DX
PUSH CX

;   returnLength = PktExchange(pkt, callLength, maxReturnLength, calling);

;	BX _ _pkt
MOV BX,[BP+4]
PUSH BX

;	BX _ _callLength
MOV BX,[BP-2]
PUSH BX
MOV BX,2

;	CX _ _maxReturnLength
MOV CX,[BP-4]
CALL _PktExchange
ADD SP,4

;	_returnLength _ BX
MOV [BP-6],BX

;   RecordCallDest(recvdHeader);

;	BX _ _recvdHeader
POP BX
PUSH BX
CALL _RecordCallDest

;   switch (recvdHeader->callSpec.outcome) {

;	BX _ _recvdHeader
POP BX
PUSH BX
MOV CX,[BX+32]
JR X7

;     case unbound: SIGNAL(CallFailed, unbound);
X9:
MOV BX,1
MOV CX,_CallFailed
CALL _SIGNAL

;     case result: break;
X10:
JR X8

;     case protocol: SIGNAL(CallFailed, runtimeProtocol);
X11:
MOV BX,0FX
MOV CX,_CallFailed
CALL _SIGNAL

;     default: SIGNAL(CallFailed, runtimeProtocol); }; /* call failed, somehow, maybe a signal */
X12:
MOV BX,0FX
MOV CX,_CallFailed
CALL _SIGNAL
JR X8
X7:
MOV AL,CH
OR AL,AL
JNZ X12
MOV AL,CL
CMP AL,1
JZ X9
CMP AL,0
JZ X10
CMP AL,4
JZ X11
JR X12
X8:

;   SetupResponse(recvdHeader);

;	BX _ _recvdHeader
POP BX
PUSH BX
CALL _SetupResponse

;   if ((recvdHeader->type.fields)&eomField)  SIGNAL(CallFailed, runtimeProtocol);

;	BX _ _recvdHeader
POP BX
PUSH BX
MOV AL,[BX+3]
AND AL,010X
OR AL,AL
JZ X13
MOV BX,0FX
MOV CX,_CallFailed
CALL _SIGNAL
X13:

;   return returnLength; };

;	BX _ _returnLength
MOV BX,[BP-6]
MOV SP,BP
POP BP
RET;

; GenerateIdlerResponse(recvd) struct PBI *recvd; { /* Ack */
_GenerateIdlerResponse:
PUSH BP
MOV BP,SP
PUSH BX

;   struct PBI *ackPkt;

;   struct Header *header;

;   struct Header *recvdHeader;

;   num workerPSB;
ADD SP,0FFF8X

;   ackPkt = GetPBI(mySoc);
MOV BX,_mySoc
CALL _GetPBI

;	_ackPkt _ BX
MOV [BP-4],BX

;   header = ackPkt->pup;

;	BX _ _ackPkt
MOV BX,[BP-4]
MOV CX,[BX+6]

;	_header _ CX
MOV [BP-6],CX

;   recvdHeader = recvd->pup;

;	BX _ _recvd
MOV BX,[BP-2]
MOV CX,[BX+6]

;	_recvdHeader _ CX
MOV [BP-8],CX

;   workerPSB = recvdHeader->destPSB; /* as adjusted by FindCallee */

;	BX _ _recvdHeader
MOV BX,[BP-8]
MOV CX,[BX+4]

;	_workerPSB _ CX
POP DX
PUSH CX

;   ++idlerAckCount;
INC _idlerAckCount

;   SetupResponse(recvdHeader);

;	BX _ _recvdHeader
MOV BX,[BP-8]
CALL _SetupResponse

;   MoveBlock(header, recvdHeader, lenHeader);

;	BX _ _header
MOV BX,[BP-6]
PUSH BX
MOV BX,014X

;	CX _ _recvdHeader
MOV CX,[BP-8]
CALL _MoveBlock
POP DX

;   header->type.fields = typeAck;

;	BX _ _header
MOV BX,[BP-6]
MOV BYTE PTR [BX+3],062X

;   header->srceHost.w = myHost.w;

;	BX _ _header
MOV BX,[BP-6]
MOV CX,WORD PTR _myHost
MOV [BX+14],CX

;   header->srceSoc.LS = rpcSocket;

;	BX _ _header
MOV BX,[BP-6]
MOV BYTE PTR [BX+19],01EX

;   header->srcePSB = workerPSB;

;	BX _ _header
MOV BX,[BP-6]

;	CX _ _workerPSB
POP CX
PUSH CX
MOV [BX+6],CX

;   SendPup(ackPkt); Block(); }; /* hit it hard, and wish it well. */

;	BX _ _ackPkt
MOV BX,[BP-4]
CALL _SendPup
CALL _Block
MOV SP,BP
POP BP
RET;

; static EnqueueForNewPSB(recvd) struct PBI *recvd; {
_EnqueueForNewPSB:
PUSH BP
MOV BP,SP
PUSH BX

; 	struct PBI *pupPkt;

; 	struct Header *header, *recvdHeader;
ADD SP,0FFFAX

; 	pupPkt = GetPBI(mySoc);
MOV BX,_mySoc
CALL _GetPBI

;	_pupPkt _ BX
MOV [BP-4],BX

; 	header = pupPkt->pup;

;	BX _ _pupPkt
MOV BX,[BP-4]
MOV CX,[BX+6]

;	_header _ CX
MOV [BP-6],CX

;    recvdHeader = recvd->pup;

;	BX _ _recvd
MOV BX,[BP-2]
MOV CX,[BX+6]

;	_recvdHeader _ CX
POP DX
PUSH CX

;    ++idlerRequeueCount;
INC _idlerRequeueCount

;    MoveBlock(header, recvdHeader, (Swab(recvdHeader->length)>>1));

;	BX _ _header
MOV BX,[BP-6]
PUSH BX

;	DI _ _recvdHeader
MOV DI,[BP-8]
MOV BX,[DI]
CALL _Swab
SHR BX

;	CX _ _recvdHeader
MOV CX,[BP-8]
CALL _MoveBlock
POP DX

;    EnqueueAgain(pupPkt); };

;	BX _ _pupPkt
MOV BX,[BP-4]
CALL _EnqueueAgain
MOV SP,BP
POP BP
RET;

; static AddCallee(stateBlock) struct CalleeState *stateBlock; { Enqueue(&callees, stateBlock); };
_AddCallee:
PUSH BP
MOV BP,SP
PUSH BX

;	BX _ _stateBlock
POP BX
PUSH BX
LEA CX,_callees
CALL _Enqueue
MOV SP,BP
POP BP
RET;

;  static RemoveCallee(stateBlock) struct CalleeState *stateBlock; {
_RemoveCallee:
PUSH BP
MOV BP,SP
PUSH BX

;  	if (Unqueue(&callees, stateBlock)==0) SIGNAL(ERROR, 0); Block(); };

;	BX _ _stateBlock
POP BX
PUSH BX
LEA CX,_callees
CALL _Unqueue
OR BX,BX
JNZ X14
XOR BX,BX
MOV CX,2
CALL _SIGNAL
X14:
CALL _Block
MOV SP,BP
POP BP
RET;

; static int /* BOOLEAN */

; FindCallee(given) struct Header *given; {
_FindCallee:
PUSH BP
MOV BP,SP
PUSH BX

;   struct CalleeState *p;

;   struct Header *stateHeader;
ADD SP,0FFFCX

;   p = (struct CalleeState *) callees.head;
MOV BX,WORD PTR _callees

;	_p _ BX
MOV [BP-4],BX

;   while (p) {
X15:

;	BX _ _p
MOV BX,[BP-4]
OR BX,BX
JZ X16

;     stateHeader = p->state;

;	BX _ _p
MOV BX,[BP-4]
MOV CX,[BX+4]

;	_stateHeader _ CX
POP DX
PUSH CX

;     if (MultEq(&stateHeader->conv, /* works because callCt follows ConvCt */

;     	      &given->conv, lenPktConversationID+1+lenCallCount))  {

;	BX _ _stateHeader
POP BX
PUSH BX
ADD BX,014X
PUSH BX

;	BX _ _given
MOV BX,[BP-2]
ADD BX,014X
PUSH BX
MOV BX,5
POP CX
CALL _MultEq
POP DX
OR BX,BX
JZ X17

; 	  given->destPSB = p->callee;

;	BX _ _given
MOV BX,[BP-2]

;	CX _ _p
MOV CX,[BP-4]
MOV DI,CX
MOV CX,[DI+2]
MOV [BX+4],CX

; 	  Block();
CALL _Block

; 	  return true; };
MOV BX,0FFFFX
MOV SP,BP
POP BP
RET;
X17:

;     p = p->next; };

;	DI _ _p
MOV DI,[BP-4]
MOV BX,[DI]

;	_p _ BX
MOV [BP-4],BX
JR X15
X16:

;   Block();
CALL _Block

;   return false; };
XOR BX,BX
MOV SP,BP
POP BP
RET;

; ForgetConnections() {
_ForgetConnections:
PUSH BP
MOV BP,SP

; 	int i;

; 	struct ConnectionData *connection;

; 	struct ConnectionData *next;

; 	for (i=0; i<128; ++i) {
ADD SP,0FFFAX
MOV WORD PTR [BP-2],0
X20:

;	BX _ _i
MOV BX,[BP-2]
CMP BX,080X
JGE X19
JR X18
X21:
INC WORD PTR [BP-2]
JR X20
X18:

; 		connection = connections[i];

;	BX _ _i
MOV BX,[BP-2]
MOV CX,_connections
SAL BX
ADD BX,CX
MOV CX,[BX]

;	_connection _ CX
MOV [BP-4],CX

; 		while (connection) {
X22:

;	BX _ _connection
MOV BX,[BP-4]
OR BX,BX
JZ X23

; 			next = connection->next;

;	DI _ _connection
MOV DI,[BP-4]
MOV BX,[DI]

;	_next _ BX
POP DX
PUSH BX

; 			connection = next; };

;	BX _ _next
POP BX
PUSH BX

;	_connection _ BX
MOV [BP-4],BX
JR X22
X23:

; 		connections[i]=0; }; };

;	BX _ _i
MOV BX,[BP-2]
MOV CX,_connections
SAL BX
ADD BX,CX
MOV WORD PTR [BX],0
JR X21
X19:
MOV SP,BP
POP BP
RET;

; static int RemC(nil1, nil2, seal)
_RemC:

; 	int nil1, nil2; struct Seal1 *seal; { RemoveCallee(seal->data[0]); return CONTINUE; };
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;	BX _ _seal
POP BX
PUSH BX
ADD BX,4
MOV CX,[BX]
MOV BX,CX
CALL _RemoveCallee
MOV BX,4
MOV SP,BP
POP BP
RET;

; ServerMain() {
_ServerMain:
PUSH BP
MOV BP,SP

;   int myPSB;

;   struct PBI *myPkt;

;   struct Header *recvdHeader;

;   struct CalleeState *myStateBlock;

;   struct Seal1 s1;

;   struct Seal s2;

;   struct Seal s4;

;   struct Seal1 s3;

;   int /* BOOL */ decrypted, newPkt;

;   int newLength;

;   int ackLen;

;   struct ConnectionData *connection;

;   struct ConnectionID id;

;   int /*BOOL*/ ok;

;   struct DispatcherDetails *target;

;   struct ExportInstance *instance;

;   int resultLength, *rout, hint;

;   int argv[4];

;   struct CallCount aCall;

;   struct Conversation *conv;

;   struct RPCCtx *CtxRunning;

;   int lll; /* Some sort of length */

;   int oldDest; /* PsbIndex */

;   int /*BOOL*/ knownCallee;
ADD SP,0FFB0X

;   CtxRunning = CurrentContext();
CALL _CurrentContext

;	_CtxRunning _ BX
MOV [BP-74],BX

;   myPSB = CtxRunning->user.myPSB;

;	BX _ _CtxRunning
MOV BX,[BP-74]
MOV CX,[BX+26]

;	_myPSB _ CX
MOV [BP-2],CX

;   myPkt = GetPBI(mySoc)
MOV BX,_mySoc
CALL _GetPBI

;	_myPkt _ BX
MOV [BP-4],BX

;   recvdHeader = myPkt->pup;

;	BX _ _myPkt
MOV BX,[BP-4]
MOV CX,[BX+6]

;	_recvdHeader _ CX
MOV [BP-6],CX

;   myStateBlock = (struct CalleeState *) GetFixed(lenCalleeState);
MOV BX,3
CALL _GetFixed

;	_myStateBlock _ BX
MOV [BP-8],BX

;   myStateBlock->callee = myPSB;

;	BX _ _myStateBlock
MOV BX,[BP-8]

;	CX _ _myPSB
MOV CX,[BP-2]
MOV [BX+2],CX

;   myStateBlock->state = recvdHeader;

;	BX _ _myStateBlock
MOV BX,[BP-8]

;	CX _ _recvdHeader
MOV CX,[BP-6]
MOV [BX+4],CX

;   newPkt = (decrypted = (newLength = 0));
MOV WORD PTR [BP-34],0
MOV WORD PTR [BP-30],0
MOV WORD PTR [BP-32],0

;   myStateBlock->next = 0;

;	BX _ _myStateBlock
MOV BX,[BP-8]
MOV WORD PTR [BX],0

;   connection = 0;
MOV WORD PTR [BP-38],0

;   s1.data[0] = (s3.data[0] = (int) myStateBlock);

;	BX _ _myStateBlock
MOV BX,[BP-8]

;	_s3+4 _ BX
MOV [BP-24],BX

;	_s1+4 _ BX
MOV [BP-10],BX

; while (true) {
X24:

;   DISABLE(&s1); DISABLE(&s2); DISABLE(&s3); DISABLE(&s4);
;&_s1
LEA BX,[BP-14]
CALL _DISABLE
;&_s2
LEA BX,[BP-18]
CALL _DISABLE
;&_s3
LEA BX,[BP-28]
CALL _DISABLE
;&_s4
LEA BX,[BP-22]
CALL _DISABLE

;   if (newPkt == 0)  {

;	BX _ _newPkt
MOV BX,[BP-32]
OR BX,BX
JNZ X26

;   	IdleReceive(myPkt, maxPupWords);
MOV BX,065X

;	CX _ _myPkt
MOV CX,[BP-4]
CALL _IdleReceive

;   	newPkt = true; decrypted = false;
MOV WORD PTR [BP-32],0FFFFX
MOV WORD PTR [BP-30],0

; 	if ((recvdHeader->type.fields&classField) == call

; 		&& ((recvdHeader->type.fields&ackField) !=0))  newPkt = newPkt; };

;	BX _ _recvdHeader
MOV BX,[BP-6]
MOV AL,[BX+3]
AND AL,7
OR AL,AL
JNZ X28

;	BX _ _recvdHeader
MOV BX,[BP-6]
MOV AL,[BX+3]
AND AL,8
OR AL,AL
JZ X28
MOV AL,1
JR X29
X28:
XOR AL,AL
X29:
OR AL,AL
JZ X27

;	BX _ _newPkt
MOV BX,[BP-32]

;	_newPkt _ BX
MOV [BP-32],BX
X27:
X26:

;   Move2(&id.conv, &recvdHeader->conv);

;	BX _ _recvdHeader
MOV BX,[BP-6]
ADD BX,014X
;&_id
LEA CX,[BP-46]
CALL _Move2

;   id.caller = recvdHeader->srceHost;

;	BX _ _recvdHeader
MOV BX,[BP-6]
MOV CX,[BX+14]

;	_id+4 _ CX
MOV [BP-42],CX

;   id.activity = recvdHeader->srcePSB;

;	BX _ _recvdHeader
MOV BX,[BP-6]
MOV CX,[BX+6]

;	_id+6 _ CX
MOV [BP-40],CX

;   Block();
CALL _Block

;   connection = connections[(Swab(id.caller.w ^ id.activity)) & 127];

;	BX _ _id+6
MOV BX,[BP-40]

;	CX _ _id+4
MOV CX,[BP-42]
XOR CX,BX
MOV BX,CX
CALL _Swab
AND BX,07FX
MOV CX,_connections
SAL BX
ADD BX,CX
MOV CX,[BX]

;	_connection _ CX
MOV [BP-38],CX

;   while (connection)  {
X30:

;	BX _ _connection
MOV BX,[BP-38]
OR BX,BX
JZ X31

;     if (MultEq(&id.conv, &connection->id.conv, lenPktConversationID+1) &&

;     recvdHeader->srcePSB == connection->id.activity)  {
;&_id
LEA BX,[BP-46]
PUSH BX

;	BX _ _connection
MOV BX,[BP-38]
INC BX
INC BX
PUSH BX
MOV BX,3
POP CX
CALL _MultEq
POP DX
OR BX,BX
JZ X33

;	BX _ _recvdHeader
MOV BX,[BP-6]
MOV CX,[BX+6]

;	BX _ _connection
MOV BX,[BP-38]
MOV AX,[BX+8]
CMP CX,AX
JNZ X33
MOV AL,1
JR X34
X33:
XOR AL,AL
X34:
OR AL,AL
JZ X32

;       myPkt->convHandle = connection->conv;

;	BX _ _myPkt
MOV BX,[BP-4]

;	CX _ _connection
MOV CX,[BP-38]
MOV DI,CX
MOV CX,[DI+14]
MOV [BX+4],CX

;       if (decrypted == false) {

;	BX _ _decrypted
MOV BX,[BP-30]
OR BX,BX
JNZ X35

;       	if (connection->conv != unencrypted) {

;	BX _ _connection
MOV BX,[BP-38]
MOV CX,[BX+14]
OR CX,CX
JZ X36

;       		ok = DecryptPkt(recvdHeader, myPkt->convHandle, &newLength);

;	BX _ _recvdHeader
MOV BX,[BP-6]
PUSH BX

;	BX _ _myPkt
MOV BX,[BP-4]
MOV CX,[BX+4]
;&_newLength
LEA BX,[BP-34]
CALL _DecryptPkt
POP DX

;	_ok _ BX
MOV [BP-48],BX

;       		decrypted=true;
MOV WORD PTR [BP-30],0FFFFX

;       		if (ok==false) goto CallerPhoney; };

;	BX _ _ok
MOV BX,[BP-48]
OR BX,BX
JNZ X37
JMP _CallerPhoney
X37:

;       	else { newLength = (Swab(recvdHeader->length) >>1) - pktLengthOverhead;
JR X38
X36:

;	DI _ _recvdHeader
JR $+5
X31:
JMP X39
MOV DI,[BP-6]
MOV BX,[DI]
CALL _Swab
SHR BX
ADD BX,0FFEBX

;	_newLength _ BX
MOV [BP-34],BX

;       			decrypted=true; }; };
MOV WORD PTR [BP-30],0FFFFX
X38:
X35:

;       if (recvdHeader->pktID.activity != recvdHeader->srcePSB)  goto CallerPhoney;

;	BX _ _recvdHeader
MOV BX,[BP-6]
MOV CX,[BX+24]

;	BX _ _recvdHeader
MOV BX,[BP-6]
MOV AX,[BX+6]
CMP CX,AX
JZ X40
JMP _CallerPhoney
X40:

;       if ((recvdHeader->type.fields&classField) != call)  goto CallerOld;

;	BX _ _recvdHeader
MOV BX,[BP-6]
JR $+5
X32:
JMP X42
MOV AL,[BX+3]
AND AL,7
OR AL,AL
JZ X41
JMP _CallerOld
X41:

;       if (DoubleComp(&recvdHeader->pktID.callCt, &connection->callCt)>0)  {

;	BX _ _recvdHeader
MOV BX,[BP-6]
ADD BX,01AX

;	CX _ _connection
MOV CX,[BP-38]
ADD CX,0AX
XCHG BX,CX
CALL _DoubleComp
CMP BX,0
JLE X43

;         if (recvdHeader->pktID.pktSeq != swapped1)  goto CallerPhoney;

;	BX _ _recvdHeader
MOV BX,[BP-6]
MOV CX,[BX+30]
MOV BX,CX
CMP BX,0100X
JZ X44
JMP _CallerPhoney
X44:

; 		Move2(&connection->callCt, &recvdHeader->pktID.callCt);

;	BX _ _connection
MOV BX,[BP-38]
ADD BX,0AX

;	CX _ _recvdHeader
MOV CX,[BP-6]
ADD CX,01AX
XCHG BX,CX
CALL _Move2

; 		AddCallee(myStateBlock);

;	BX _ _myStateBlock
MOV BX,[BP-8]
CALL _AddCallee

; 		goto CallerNew; };
JMP _CallerNew

;       else goto CallerOld; };
X43:
JMP _CallerOld
X42:

;       connection = connection->next; };

;	DI _ _connection
MOV DI,[BP-38]
MOV BX,[DI]

;	_connection _ BX
MOV [BP-38],BX
JMP X30
X39:

;   if ((recvdHeader->type.fields&classField) == call) goto CallerUnknown; else goto CallerOld;

;	BX _ _recvdHeader
MOV BX,[BP-6]
MOV AL,[BX+3]
AND AL,7
OR AL,AL
JNZ X45
JMP _CallerUnknown
X45:
JMP _CallerOld

;   SIGNAL(ERROR, 0); /* no where to go! */
XOR BX,BX
MOV CX,2
CALL _SIGNAL
_CallerNew:

;       CallerNew: {

; 		Block();
CALL _Block

; 		target = &recvdHeader->callSpec.dispatcherDet;

;	BX _ _recvdHeader
MOV BX,[BP-6]
ADD BX,020X

;	_target _ BX
MOV [BP-50],BX

; 		SetupResponse(recvdHeader);

;	BX _ _recvdHeader
MOV BX,[BP-6]
CALL _SetupResponse

; 		if (((hint=Swab(target->dispatcherHint)) >= used) ||

; 		   ((instance = &exportTable[hint]) != instance) ||

; 		   (!DoubleEq(&target->dispatcherID, &instance->id))) {

;	BX _ _target
MOV BX,[BP-50]
MOV CX,[BX+6]
MOV BX,CX
CALL _Swab

;	_hint _ BX
MOV [BP-58],BX
MOV CX,_used
CMP BX,CX
JGE X48

;	BX _ _hint
MOV BX,[BP-58]
LEA CX,_exportTable
MOV AX,012X
IMUL AX,BX
ADD AX,CX

;	_instance _ AX
MOV [BP-52],AX

;	BX _ _instance
MOV BX,[BP-52]
CMP AX,BX
JNZ X50

;	BX _ _target
MOV BX,[BP-50]
INC BX
INC BX

;	CX _ _instance
MOV CX,[BP-52]
INC CX
INC CX
XCHG BX,CX
CALL _DoubleEq
OR BX,BX
JNZ X49
X50:
MOV AL,1
JR X51
X49:
XOR AL,AL
X51:
OR AL,AL
JZ X47
X48:
MOV AL,1
JR X52
X47:
XOR AL,AL
X52:
OR AL,AL
JZ X46

; 			recvdHeader->callSpec.outcome = unbound; resultLength = 0; };

;	BX _ _recvdHeader
MOV BX,[BP-6]
MOV WORD PTR [BX+32],1
MOV WORD PTR [BP-54],0

; 		else {
JR X53
X46:

; 			rout = instance->dispatcher;

;	BX _ _instance
MOV BX,[BP-52]
MOV CX,[BX+6]

;	_rout _ CX
MOV [BP-56],CX

; 			ENABLE(UNWIND, &RemC, &s3);
MOV BX,1
PUSH BX
;&_s3
LEA BX,[BP-28]
MOV CX,OFFSET _RemC
CALL _ENABLE
POP DX

; 			if (ENABLE(RejectUnbound, &CONT, &s4))  {
MOV BX,_RejectUnbound
PUSH BX
;&_s4
LEA BX,[BP-22]
MOV CX,OFFSET _CONT
CALL _ENABLE
POP DX
OR BX,BX
JZ X54

; 				recvdHeader->callSpec.outcome = unbound; resultLength = 0; };

;	BX _ _recvdHeader
MOV BX,[BP-6]
MOV WORD PTR [BX+32],1
MOV WORD PTR [BP-54],0

; 			else if (ENABLE(RejectProtocol, &CONT, &s2)) {
JR X55
X54:
MOV BX,_RejectProtocol
PUSH BX
;&_s2
LEA BX,[BP-18]
MOV CX,OFFSET _CONT
CALL _ENABLE
POP DX
OR BX,BX
JZ X56

; 				recvdHeader->callSpec.outcome = protocol; resultLength = 0; };

;	BX _ _recvdHeader
MOV BX,[BP-6]
MOV WORD PTR [BX+32],4
MOV WORD PTR [BP-54],0

; 			else if (ENABLE(CallFailed, &RemC, &s1))  { newPkt=false; continue; };
JR X57
X56:
MOV BX,_CallFailed
PUSH BX
;&_s1
LEA BX,[BP-14]
MOV CX,OFFSET _RemC
CALL _ENABLE
POP DX
OR BX,BX
JZ X58
MOV WORD PTR [BP-32],0
JMP X24

;     		else {
X58:

; 			argv[0] = (int) myPkt;

;	BX _ _myPkt
MOV BX,[BP-4]

;	_argv _ BX
JR $+5
X53:
JMP X59
MOV [BP-66],BX

; 			argv[1] = newLength;

;	BX _ _newLength
MOV BX,[BP-34]

;	_argv+2 _ BX
MOV [BP-64],BX

; 			argv[2] = (int) connection->conv;

;	BX _ _connection
MOV BX,[BP-38]
MOV CX,[BX+14]

;	_argv+4 _ CX
MOV [BP-62],CX

; 			argv[3] = (int) instance->dispatcherArgs;

;	BX _ _instance
MOV BX,[BP-52]
MOV CX,[BX+8]

;	_argv+6 _ CX
MOV [BP-60],CX

; 			resultLength= apply(argv, rout, 4); };
;&_argv
LEA BX,[BP-66]
PUSH BX
MOV BX,4

;	CX _ _rout
MOV CX,[BP-56]
CALL _apply
POP DX

;	_resultLength _ BX
MOV [BP-54],BX
X57:
X55:

; 			DISABLE(&s2); DISABLE(&s3); DISABLE(&s4);
;&_s2
LEA BX,[BP-18]
CALL _DISABLE
;&_s3
LEA BX,[BP-28]
CALL _DISABLE
;&_s4
LEA BX,[BP-22]
CALL _DISABLE

; 			};
X59:

; 		RemoveCallee(myStateBlock);

;	BX _ _myStateBlock
MOV BX,[BP-8]
CALL _RemoveCallee

;         if (ENABLE(CallFailed, &CONT, &s1))  newPkt=false;
MOV BX,_CallFailed
PUSH BX
;&_s1
LEA BX,[BP-14]
MOV CX,OFFSET _CONT
CALL _ENABLE
POP DX
OR BX,BX
JZ X60
MOV WORD PTR [BP-32],0

; 		else {
JR X61
X60:

; 	   		newLength = PktExchange(myPkt, resultLength, serverDataLength, endCall);

;	BX _ _myPkt
MOV BX,[BP-4]
PUSH BX

;	BX _ _resultLength
MOV BX,[BP-54]
PUSH BX
MOV BX,3
MOV CX,076X
CALL _PktExchange
ADD SP,4

;	_newLength _ BX
MOV [BP-34],BX

; 	   		newPkt = (newLength >= 0); };

;	BX _ _newLength
MOV BX,[BP-34]
CMP BX,0
JL X62
MOV BX,1
JR X63
X62:
XOR BX,BX
X63:

;	_newPkt _ BX
MOV [BP-32],BX
X61:

; 	   	if (newPkt) decrypted = true;

;	BX _ _newPkt
MOV BX,[BP-32]
OR BX,BX
JZ X64
MOV WORD PTR [BP-30],0FFFFX
X64:

; 		continue;};
JMP X24
_CallerUnknown:

;     CallerUnknown: {

;     	Block();
CALL _Block

; 		ok = (ENABLE(CallFailed, &CONT, &s1) == false && 

; 	        GetConnectionState(decrypted, myPkt, &id, &aCall, &conv, &lll) == true);
MOV BX,_CallFailed
PUSH BX
;&_s1
LEA BX,[BP-14]
MOV CX,OFFSET _CONT
CALL _ENABLE
POP DX
OR BX,BX
JNZ X65

;	BX _ _decrypted
MOV BX,[BP-30]
PUSH BX

;	BX _ _myPkt
MOV BX,[BP-4]
PUSH BX
;&_id
LEA BX,[BP-46]
PUSH BX
;&_aCall
LEA BX,[BP-70]
PUSH BX
;&_lll
LEA BX,[BP-76]
;&_conv
LEA CX,[BP-72]
CALL _GetConnectionState
ADD SP,8
CMP BX,0FFFFX
X65:
JNZ X66
MOV BX,1
JR X67
X66:
XOR BX,BX
X67:

;	_ok _ BX
MOV [BP-48],BX

; 		if (ok) {

;	BX _ _ok
MOV BX,[BP-48]
OR BX,BX
JZ X68

; 			if (newPkt == false) SIGNAL(ERROR, 0);

;	BX _ _newPkt
MOV BX,[BP-32]
OR BX,BX
JNZ X69
XOR BX,BX
MOV CX,2
CALL _SIGNAL
X69:

; 			if (decrypted == false) { decrypted = true; newLength = lll; };

;	BX _ _decrypted
MOV BX,[BP-30]
OR BX,BX
JNZ X70
MOV WORD PTR [BP-30],0FFFFX

;	BX _ _lll
MOV BX,[BP-76]

;	_newLength _ BX
MOV [BP-34],BX
X70:

; 			NoteConnection(&id, &aCall, conv); };
;&_id
LEA BX,[BP-46]
PUSH BX

;	BX _ _conv
MOV BX,[BP-72]
;&_aCall
LEA CX,[BP-70]
CALL _NoteConnection
POP DX

; 		else newPkt = false;
JR X71
X68:
MOV WORD PTR [BP-32],0
X71:

; 		continue ; };
JMP X24
_CallerPhoney:

;     CallerPhoney: /* ignorable packet */

; 		newPkt = false; continue;
MOV WORD PTR [BP-32],0
JMP X24
_CallerOld:

;     CallerOld: {

;     	Block();
CALL _Block

;     	oldDest = recvdHeader->destPSB;

;	BX _ _recvdHeader
MOV BX,[BP-6]
MOV CX,[BX+4]

;	_oldDest _ CX
MOV [BP-78],CX

;     	knownCallee = ((decrypted == true) && (FindCallee(recvdHeader) != 0));

;	BX _ _decrypted
MOV BX,[BP-30]
CMP BX,0FFFFX
JNZ X72

;	BX _ _recvdHeader
MOV BX,[BP-6]
CALL _FindCallee
OR BX,BX
JZ X72
MOV AL,1
JR X73
X72:
XOR AL,AL
X73:
XOR AH,AH

;	_knownCallee _ AX
POP DX
PUSH AX

;     	if ((knownCallee==true) && (recvdHeader->destPSB != oldDest)) {

;	BX _ _knownCallee
POP BX
PUSH BX
CMP BX,0FFFFX
JNZ X75

;	BX _ _recvdHeader
MOV BX,[BP-6]
MOV CX,[BX+4]

;	BX _ _oldDest
MOV BX,[BP-78]
CMP CX,BX
JZ X75
MOV AL,1
JR X76
X75:
XOR AL,AL
X76:
OR AL,AL
JZ X74

;     		if (decrypted) {

;	BX _ _decrypted
MOV BX,[BP-30]
OR BX,BX
JZ X77

;     			if (myPkt->convHandle == unencrypted)

;	BX _ _myPkt
MOV BX,[BP-4]
MOV CX,[BX+4]
OR CX,CX
JNZ X78

;     				ackLen = pktLengthOverhead + newLength;

;	BX _ _newLength
MOV BX,[BP-34]
ADD BX,015X

;	_ackLen _ BX
MOV [BP-36],BX

;     			else ackLen = EncryptPkt(myPkt, newLength);
JR X79
X78:

;	BX _ _newLength
MOV BX,[BP-34]

;	CX _ _myPkt
MOV CX,[BP-4]
CALL _EncryptPkt

;	_ackLen _ BX
MOV [BP-36],BX
X79:

;     			recvdHeader->length = Swab(ackLen << 1); };

;	BX _ _ackLen
MOV BX,[BP-36]
SAL BX
CALL _Swab
MOV CX,BX

;	BX _ _recvdHeader
MOV BX,[BP-6]
MOV [BX],CX
X77:

;     		EnqueueForNewPSB(myPkt); };

;	BX _ _myPkt
MOV BX,[BP-4]
CALL _EnqueueForNewPSB

;     	else {
JR X80
X74:

;     		if ((recvdHeader->type.fields&ackField) &&

;     			((recvdHeader->type.fields&eomField) == 0) &&

;     			(((recvdHeader->type.fields&classField) == xtraData) || (knownCallee==true))) {

;	BX _ _recvdHeader
MOV BX,[BP-6]
MOV AL,[BX+3]
AND AL,8
OR AL,AL
JZ X82

;	BX _ _recvdHeader
MOV BX,[BP-6]
MOV AL,[BX+3]
AND AL,010X
OR AL,AL
JNZ X83

;	BX _ _recvdHeader
MOV BX,[BP-6]
MOV AL,[BX+3]
AND AL,7
CMP AL,1
JZ X85

;	BX _ _knownCallee
POP BX
PUSH BX
CMP BX,0FFFFX
X85:
X84:
X83:
JNZ X82
MOV AL,1
JR X86
X82:
XOR AL,AL
X86:
OR AL,AL
JZ X81

;     				if ((!decrypted) || (myPkt->convHandle == unencrypted))

;	BX _ _decrypted
MOV BX,[BP-30]
OR BX,BX
JZ X89

;	BX _ _myPkt
MOV BX,[BP-4]
MOV CX,[BX+4]
OR CX,CX
X89:
X88:
JNZ X87

;     					ackLen = pktLengthOverhead;
MOV WORD PTR [BP-36],015X

;     				else ackLen = EncryptPkt(myPkt, 0);
JR X90
X87:
XOR BX,BX

;	CX _ _myPkt
MOV CX,[BP-4]
CALL _EncryptPkt

;	_ackLen _ BX
MOV [BP-36],BX
X90:

;     				recvdHeader->length = Swab(ackLen << 1);

;	BX _ _ackLen
MOV BX,[BP-36]
SAL BX
CALL _Swab
MOV CX,BX

;	BX _ _recvdHeader
MOV BX,[BP-6]
MOV [BX],CX

;     				GenerateIdlerResponse(myPkt); }; };

;	BX _ _myPkt
MOV BX,[BP-4]
CALL _GenerateIdlerResponse
X81:
X80:

;        		newPkt=false;
MOV WORD PTR [BP-32],0

; 		continue; }; }; /* endloop */ };
JMP X24
X25:
MOV SP,BP
POP BP
RET;

; static int one[2];	

; static NoteConnection(id, callCt, conv) 
_NoteConnection:

; 	struct ConnectionID *id;

; 	struct CallCount *callCt;

; 	struct Conversation *conv; {
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   struct ConnectionData *dataPtr;

;   struct ConnectionData *connection;
ADD SP,0FFFCX

;   dataPtr =

; 	(struct ConnectionData *) &connections[(Swab(id->caller.w ^ id->activity)) & 127];

;	BX _ _id
MOV BX,[BP+4]
MOV CX,[BX+4]

;	BX _ _id
MOV BX,[BP+4]
MOV AX,[BX+6]
XOR CX,AX
MOV BX,CX
CALL _Swab
AND BX,07FX
MOV CX,_connections
SAL BX
ADD BX,CX

;	_dataPtr _ BX
MOV [BP-6],BX

;   connection = dataPtr->next;

;	DI _ _dataPtr
MOV DI,[BP-6]
MOV BX,[DI]

;	_connection _ BX
POP DX
PUSH BX

;   while (connection)   { /* SELECT TRUE FROM .. */
X91:

;	BX _ _connection
POP BX
PUSH BX
OR BX,BX
JZ X92

;     if (MultEq(id, &connection->id, lenConnectionID))  return; /* Already there!? -- */

;	BX _ _id
MOV BX,[BP+4]
PUSH BX

;	BX _ _connection
MOV BX,[BP-8]
INC BX
INC BX
PUSH BX
MOV BX,4
POP CX
CALL _MultEq
POP DX
OR BX,BX
JZ X93
MOV SP,BP
POP BP
RET;
X93:

;     dataPtr = connection;

;	BX _ _connection
POP BX
PUSH BX

;	_dataPtr _ BX
MOV [BP-6],BX

;     connection = dataPtr->next; }; /* endloop */

;	DI _ _dataPtr
MOV DI,[BP-6]
MOV BX,[DI]

;	_connection _ BX
POP DX
PUSH BX
JR X91
X92:

;   connection = (struct ConnectionData *) GetFixed(lenConnectionData);
MOV BX,8
CALL _GetFixed

;	_connection _ BX
POP DX
PUSH BX

;   connection->next = 0;

;	BX _ _connection
POP BX
PUSH BX
MOV WORD PTR [BX],0

;   MoveBlock(&connection->id, id, lenConnectionID);

;	BX _ _connection
POP BX
PUSH BX
INC BX
INC BX
PUSH BX
MOV BX,4

;	CX _ _id
MOV CX,[BP+4]
CALL _MoveBlock
POP DX

;   Move2(&connection->callCt, callCt);

;	BX _ _connection
POP BX
PUSH BX
ADD BX,0AX
PUSH BX

;	BX _ _callCt
MOV BX,[BP-2]
POP CX
CALL _Move2

;   DoubleDiff(&connection->callCt, one);

;	BX _ _connection
POP BX
PUSH BX
ADD BX,0AX
PUSH BX
LEA BX,_one
POP CX
CALL _DoubleDiff

;   connection->conv = conv;

;	BX _ _connection
POP BX
PUSH BX

;	CX _ _conv
MOV CX,[BP-4]
MOV [BX+14],CX

;   dataPtr->next = connection;  Block(); };

;	BX _ _dataPtr
MOV BX,[BP-6]

;	CX _ _connection
POP CX
PUSH CX
MOV [BX],CX
CALL _Block
MOV SP,BP
POP BP
RET;

;  SetupResponse(header) struct Header *header; {
_SetupResponse:
PUSH BP
MOV BP,SP
PUSH BX

;   header->destHost = header->srceHost;

;	BX _ _header
POP BX
PUSH BX

;	CX _ _header
POP CX
PUSH CX
MOV DI,CX
MOV CX,[DI+14]
MOV [BX+8],CX

;   header->destSoc.LS = rpcSocket;

;	BX _ _header
POP BX
PUSH BX
MOV BYTE PTR [BX+13],01EX

;   header->destPSB = header->srcePSB;

;	BX _ _header
POP BX
PUSH BX

;	CX _ _header
POP CX
PUSH CX
MOV DI,CX
MOV CX,[DI+6]
MOV [BX+4],CX

;   header->callSpec.outcome = result; Block(); };

;	BX _ _header
POP BX
PUSH BX
MOV WORD PTR [BX+32],0
CALL _Block
MOV SP,BP
POP BP
RET;

; StreamInitialize() {
_StreamInitialize:
PUSH BP
MOV BP,SP

;   one[0] = swapped1;
MOV _one,0100X

;   lastCallDest = GetFixed(maxPSB+1);
MOV BX,010X
CALL _GetFixed
MOV _lastCallDest,BX

;   connections = (struct ConnectionData **) GetFixed(128);
MOV BX,080X
CALL _GetFixed
MOV _connections,BX

;   MisusedConversation = CODE(); };
CALL _CODE
MOV _MisusedConversation,BX
MOV SP,BP
POP BP
RET;

; StreamRestart() {ForgetConnections()};
_StreamRestart:
PUSH BP
MOV BP,SP
CALL _ForgetConnections
MOV SP,BP
POP BP
RET;

; Externals Declared Here
PUBLIC _MisusedConversation
PUBLIC _connections
PUBLIC _callees
PUBLIC _lastCallDest
PUBLIC _StartCall
PUBLIC _Call
PUBLIC _SetupResponse
PUBLIC _GenerateIdlerResponse
PUBLIC _ForgetConnections
PUBLIC _ServerMain
PUBLIC _StreamInitialize
PUBLIC _StreamRestart

C_CODE ENDS

; Number of Bytes of Code = 096EX, (2414)