-- Copyright (C) 1981, 1984, 1985 by Xerox Corporation. All rights reserved.
-- RetrieveGV.mesa, Transport Mechanism: User: Access to mail on GV servers --
-- HGM, 15-Sep-85 7:58:31
-- Mark Johnson 12-Nov-81 10:22:52 --
-- Andrew Birrell 21-Jan-81 17:08:41 --
DIRECTORY
BodyDefs USING [ItemHeader, ItemLength, RName, Timestamp],
Inline USING [LowHalf],
NameInfoDefs USING [AuthenticateInfo],
ProtocolDefs USING [
CreateStream, DestroyStream, Init, Failed, FailureReason, Handle,
mailServerOutputSocket, ReceiveAck, ReceiveBoolean, ReceiveByte, ReceiveCount,
ReceiveItemHeader, ReceiveRemark, ReceiveRName, ReceiveTimestamp, SendNow,
SendMSOperation, SendPassword, SendRemark, SendRName],
PupDefs USING [PupAddress],
PupStream USING [StreamClosing],
RetrieveDefs USING [Failed, FailureReason],
RetrieveXDefs USING [Handle, ServerAddress],
Stream USING [
Block, CompletionCode, GetBlock, Handle, SubSequenceType, TimeOut];
RetrieveGV: MONITOR LOCKS handle USING handle: RetrieveXDefs.Handle
IMPORTS Inline, ProtocolDefs, PupStream, RetrieveDefs, RetrieveXDefs, Stream
EXPORTS RetrieveXDefs =
BEGIN
Fail: PROC [why: ProtocolDefs.FailureReason] = {
ERROR RetrieveDefs.Failed[
IF why = protocolError THEN unknownFailure ELSE communicationFailure]};
WrongCallSequence: ERROR = CODE;
GVNextMessage: PUBLIC ENTRY PROCEDURE [handle: RetrieveXDefs.Handle]
RETURNS [msgExists: BOOLEAN, archived: BOOLEAN, deleted: BOOLEAN] =
BEGIN
ENABLE { ProtocolDefs.Failed => Fail[why]; UNWIND => NULL};
IF handle.state = beforeMBX THEN
BEGIN
addr: PupDefs.PupAddress ← RetrieveXDefs.ServerAddress[handle];
-- we exited by a signal if the address wasn't available --
addr.socket ← ProtocolDefs.mailServerOutputSocket;
IF handle.currentStr # NIL THEN ERROR;
handle.currentStr ← ProtocolDefs.CreateStream[handle.currentMBX.addr];
ProtocolDefs.SendMSOperation[handle.currentStr, openMBX];
ProtocolDefs.SendRName[handle.currentStr, handle.userName];
ProtocolDefs.SendPassword[
str: handle.currentStr, pw: handle.userKey, key: [0, 0, 0, 0]];
ProtocolDefs.SendNow[handle.currentStr];
BEGIN
info: NameInfoDefs.AuthenticateInfo = LOOPHOLE[ProtocolDefs.ReceiveByte[
handle.currentStr]];
SELECT info FROM
allDown => ERROR RetrieveDefs.Failed[communicationFailure];
notFound, group, badPwd => ERROR RetrieveDefs.Failed[badCredentials];
individual => NULL;
ENDCASE => ERROR RetrieveDefs.Failed[unknownFailure];
END;
handle.messages ← ProtocolDefs.ReceiveCount[handle.currentStr];
handle.state ← afterMessage;
END;
WHILE handle.state = inBody DO [] ← InnerNextItem[handle]; ENDLOOP;
IF handle.state = beforeBody THEN handle.state ← afterMessage;
-- handle.state is now afterMessage or afterMBX --
IF handle.messages = 0 THEN {
handle.state ← afterMBX; RETURN[FALSE, FALSE, FALSE]}
ELSE
BEGIN
handle.messages ← handle.messages - 1;
ProtocolDefs.SendMSOperation[handle.currentStr, nextMessage];
ProtocolDefs.SendNow[handle.currentStr];
msgExists ← ProtocolDefs.ReceiveBoolean[handle.currentStr];
archived ← ProtocolDefs.ReceiveBoolean[handle.currentStr];
deleted ← ProtocolDefs.ReceiveBoolean[handle.currentStr];
IF msgExists THEN handle.state ← beforeBody ELSE ERROR;
END;
END;
GVReadTOC: PUBLIC ENTRY PROCEDURE [handle: RetrieveXDefs.Handle, text: LONG STRING] =
BEGIN
ENABLE { ProtocolDefs.Failed => Fail[why]; UNWIND => NULL};
WHILE handle.state = inBody DO [] ← InnerNextItem[handle]; ENDLOOP;
IF handle.state # beforeBody THEN ERROR WrongCallSequence[];
ProtocolDefs.SendMSOperation[handle.currentStr, readTOC];
ProtocolDefs.SendNow[handle.currentStr];
ProtocolDefs.ReceiveRemark[handle.currentStr, text];
END;
GVStartMessage: PUBLIC ENTRY PROCEDURE [
handle: RetrieveXDefs.Handle, postmark: LONG POINTER TO BodyDefs.Timestamp ← NIL,
sender: BodyDefs.RName ← NIL, returnTo: BodyDefs.RName ← NIL] =
BEGIN
ENABLE { ProtocolDefs.Failed => Fail[why]; UNWIND => NULL};
InnerStartMessage[handle, postmark, sender, returnTo];
END;
InnerStartMessage: INTERNAL PROCEDURE [
handle: RetrieveXDefs.Handle, postmark: LONG POINTER TO BodyDefs.Timestamp ← NIL,
sender: BodyDefs.RName ← NIL, returnTo: BodyDefs.RName ← NIL] =
BEGIN
WHILE handle.state = inBody DO [] ← InnerNextItem[handle]; ENDLOOP;
IF handle.state # beforeBody THEN ERROR WrongCallSequence[];
ProtocolDefs.SendMSOperation[handle.currentStr, readMessage];
ProtocolDefs.SendNow[handle.currentStr];
handle.state ← inBody;
handle.header ← ProtocolDefs.ReceiveItemHeader[handle.currentStr];
IF handle.header.type # PostMark THEN ERROR;
IF postmark # NIL THEN
postmark↑ ← ProtocolDefs.ReceiveTimestamp[handle.currentStr]
ELSE InnerSkipItem[handle];
handle.header ← ProtocolDefs.ReceiveItemHeader[handle.currentStr];
IF handle.header.type # Sender THEN ERROR;
IF sender # NIL THEN ProtocolDefs.ReceiveRName[handle.currentStr, sender]
ELSE InnerSkipItem[handle];
handle.header ← ProtocolDefs.ReceiveItemHeader[handle.currentStr];
IF handle.header.type # ReturnTo THEN ERROR;
IF returnTo # NIL THEN ProtocolDefs.ReceiveRName[handle.currentStr, returnTo]
ELSE InnerSkipItem[handle];
handle.header.length ← 0; -- no more data in this item --
END;
GVNextItem: PUBLIC ENTRY PROCEDURE [handle: RetrieveXDefs.Handle]
RETURNS [itemHeader: BodyDefs.ItemHeader] =
BEGIN
ENABLE { ProtocolDefs.Failed => Fail[why]; UNWIND => NULL};
IF handle.state # inBody THEN InnerStartMessage[handle];
RETURN[InnerNextItem[handle]]
END;
InnerNextItem: INTERNAL PROCEDURE [handle: RetrieveXDefs.Handle]
RETURNS [itemHeader: BodyDefs.ItemHeader] =
BEGIN
IF handle.state # inBody THEN ERROR WrongCallSequence[];
IF handle.header.length > 0 OR handle.spareByte THEN InnerSkipItem[handle];
handle.header ← ProtocolDefs.ReceiveItemHeader[handle.currentStr];
-- arrange for InnerSkip to include padding byte --
handle.spareByte ← handle.header.length MOD 2 # 0;
IF handle.header.type = LastItem THEN
BEGIN
why: Stream.CompletionCode ← normal;
buffer: CHARACTER;
bufferAddr: LONG POINTER ← @buffer;
IF handle.header.length > 0 THEN InnerSkipItem[handle];
WHILE why # sstChange DO
[, why, ] ← Stream.GetBlock[
handle.currentStr, [LOOPHOLE[bufferAddr], 0, 1] !
PupStream.StreamClosing, Stream.TimeOut => Fail[communicationError]];
ENDLOOP;
handle.state ← beforeBody;
END;
itemHeader ← handle.header;
END;
GVNextBlock: PUBLIC ENTRY PROCEDURE [
handle: RetrieveXDefs.Handle,
buffer: LONG DESCRIPTOR FOR PACKED ARRAY OF CHARACTER] RETURNS [bytes: CARDINAL] =
BEGIN
-- returns 0 forever if we're at the end of the item --
ENABLE { ProtocolDefs.Failed => Fail[why]; UNWIND => NULL};
why: Stream.CompletionCode;
sst: Stream.SubSequenceType;
bufferAddr: LONG POINTER ← BASE[buffer];
IF handle.state # inBody THEN ERROR WrongCallSequence[];
[bytes, why, sst] ← Stream.GetBlock[
handle.currentStr, [
LOOPHOLE[bufferAddr], 0,
IF LENGTH[buffer] > handle.header.length THEN Inline.LowHalf[
handle.header.length] ELSE LENGTH[buffer]] !
PupStream.StreamClosing, Stream.TimeOut => Fail[communicationError]];
IF why # normal THEN ERROR;
handle.header.length ← handle.header.length - bytes;
END;
InnerSkipItem: INTERNAL PROCEDURE [handle: RetrieveXDefs.Handle] =
BEGIN
length: CARDINAL = 128;
buffer: PACKED ARRAY [0..length) OF CHARACTER;
bufferAddr: LONG POINTER ← @buffer;
used: CARDINAL;
why: Stream.CompletionCode;
sst: Stream.SubSequenceType;
IF handle.state # inBody THEN ERROR WrongCallSequence[];
IF handle.spareByte THEN handle.header.length ← handle.header.length + 1;
handle.spareByte ← FALSE;
WHILE handle.header.length > 0 DO
BEGIN
wanted: CARDINAL =
IF handle.header.length > length THEN length
ELSE Inline.LowHalf[handle.header.length];
[used, why, sst] ← Stream.GetBlock[
handle.currentStr, [LOOPHOLE[bufferAddr], 0, wanted] !
PupStream.StreamClosing, Stream.TimeOut => Fail[communicationError]];
IF why # normal THEN ERROR;
handle.header.length ← handle.header.length - used;
END;
ENDLOOP;
END;
GVWriteTOC: PUBLIC ENTRY PROCEDURE [
handle: RetrieveXDefs.Handle, text: LONG STRING] =
BEGIN
ENABLE { ProtocolDefs.Failed => Fail[why]; UNWIND => NULL};
WHILE handle.state = inBody DO [] ← InnerNextItem[handle]; ENDLOOP;
IF handle.state # beforeBody THEN ERROR WrongCallSequence[];
ProtocolDefs.SendMSOperation[handle.currentStr, writeTOC];
ProtocolDefs.SendRemark[handle.currentStr, text];
ProtocolDefs.SendNow[handle.currentStr];
ProtocolDefs.ReceiveAck[handle.currentStr];
handle.state ← beforeBody;
END;
GVDeleteMessage: PUBLIC ENTRY PROCEDURE [handle: RetrieveXDefs.Handle] =
BEGIN
ENABLE { ProtocolDefs.Failed => Fail[why]; UNWIND => NULL};
WHILE handle.state = inBody DO [] ← InnerNextItem[handle]; ENDLOOP;
IF handle.state # beforeBody THEN ERROR WrongCallSequence[];
ProtocolDefs.SendMSOperation[handle.currentStr, deleteMessage];
ProtocolDefs.SendNow[handle.currentStr];
ProtocolDefs.ReceiveAck[handle.currentStr];
handle.state ← beforeBody;
END;
GVAccept: PUBLIC INTERNAL PROCEDURE [handle: RetrieveXDefs.Handle] =
BEGIN
ENABLE { ProtocolDefs.Failed => Fail[why]; UNWIND => NULL};
IF handle.state # afterMBX THEN ERROR WrongCallSequence[];
ProtocolDefs.SendMSOperation[handle.currentStr, flushMBX];
ProtocolDefs.SendNow[handle.currentStr];
ProtocolDefs.ReceiveAck[handle.currentStr];
END;
GVClose: PUBLIC INTERNAL PROCEDURE [handle: RetrieveXDefs.Handle] =
BEGIN
IF handle.currentStr # NIL THEN ProtocolDefs.DestroyStream[handle.currentStr];
handle.currentStr ← NIL;
handle.state ← beforeMBX;
END;
ProtocolDefs.Init[];
END.