DIRECTORY
BasicTime USING [GMT, Now, nullGMT, Period, Unpack, Unpacked, Update],
Convert USING [RopeFromInt, RopeFromTime],
GVBasics USING [oldestTime, RopeFromTimestamp, Timestamp],
GVNames USING [GetMembers, MemberInfo],
GVProtocol USING [ReceiveTimestamp],
IO USING [Close, int, Put, PutChar, PutF, PutFR, PutRope, rope, STREAM, time],
Process USING [Detach, SecondsToTicks],
Real USING [InlineRound], 
Rope USING [Cat, Equal, Find, ROPE],
SafeStorage USING [ReclaimCollectibleObjects],
VM USING [],
VMStatistics USING [VirtualAllocation],

Queue USING [Create, Dequeue, ElemProc, Enqueue, Enumerate, GetHead, GetProcessableElement, Inhibit, Inhibition, IsEmpty, MQ, Name, NewElem, QElem, Uninhibit, Value],
SMTPControl USING [defaultInhibitTime],
SMTPDescr USING [AddProcessedRecipient, Descr, DescrRep, Destroy, EnumerateRawRecipients, EnumerateRecipientHosts, GetArpaReversePath, GetExpiryDate, GetFormat, GetGvSender, GetPrecedeMsgText, GetUserHandle, HostProc, MoreRecipients, Print, RawRecipProc, RemoveRawRecipients, RemoveRecipientHost, RetrieveMsgStream, SetArpaReversePath, SetGvSender, SetPrecedeMsgText, StoreItemInfo, Unparse, WrongState],
SMTPGVSend USING [totalGvMsgsSent, totalGvBytesSent, Connection, Failed, Open, SendItem],
SMTPQueue USING [],
SMTPSend USING [totalArpaMsgsSent, totalArpaBytesSent, Close, Connection, Failed, Open, SendItem],
SMTPSupport USING [AuthorizationCheck, CheckHeader, Log, NotifySender],
SMTPSyntax USING [EnumerateGVItems, GVItemProc, HostAndUser, ReceiveRName, ReversePath, UnBlessReturnPath];
SMTPQueueImpl: CEDAR MONITOR
IMPORTS BasicTime, Convert, GVBasics, GVNames, GVProtocol, IO, Process, Queue, Real, Rope, SafeStorage, VMStatistics, SMTPControl, SMTPDescr, SMTPGVSend, SMTPSend, SMTPSupport, SMTPSyntax
EXPORTS SMTPQueue =
BEGIN
Descr: TYPE = SMTPDescr.Descr;
ROPE: TYPE = Rope.ROPE;
STREAM: TYPE = IO.STREAM;
QUEUE: TYPE = Queue.MQ;
ItemOnly: TYPE = REF Descr; -- an item for delivery to one or more recipients
DeliveryPkg: TYPE = REF DeliveryPkgRep; -- an item ready for delivery to a clump of recipients at the same host
DeliveryPkgRep: TYPE = RECORD[descr: Descr, recipList: LIST OF ROPE];
RecipBundle: TYPE = REF RecipBundleRep; -- a queue of delivery pkgs for a single host
RecipBundleRep: TYPE = RECORD [
queue: QUEUE,
sent, recv: INT _ 0,
lastUp: BasicTime.GMT];
EmptyQueues: QUEUE _ Queue.Create["Empty"]; -- queue of RecipBundles
GVQueue: QUEUE _ Queue.Create["GV"]; -- queue of RecipBundles
ExpressQueue: QUEUE _ Queue.Create["Ex"]; -- queue of RecipBundles
ArpaExpressQueue: QUEUE _ Queue.Create["ArpaEx"]; -- queue of RecipBundles
HostQueues: QUEUE _ Queue.Create["ARPA"]; -- queue of RecipBundles
SickQueues: QUEUE _ Queue.Create["Sick"]; -- queue of RecipBundles
BadItemQueue: QUEUE _ Queue.Create["Bad"]; -- queue of DeliveryPkgs
tempQueue: QUEUE _ Queue.Create["Temp"]; -- queue of DeliveryPkgs
gvHostName: ROPE _ "Grapevine"; -- Wired into format of msg saved on disk
expressHostName: ROPE _ "Express";
expressMail: LIST OF ROPE;
arpaExpressHostName: ROPE _ "ArpaExpress";
arpaExpressMail: LIST OF ROPE;
notExpressMail: LIST OF ROPE;

noUpArrowDLs: PUBLIC LIST OF ROPE;

expressOK: BOOL _ TRUE;
debug: BOOL _ FALSE;
ExpressList: PUBLIC PROC RETURNS[list: LIST OF ROPE] = {RETURN[expressMail]};
SetExpressOK: PUBLIC PROC [ok: BOOL] = {expressOK _ ok};
Express: PROC [names: LIST OF ROPE] RETURNS [name: ROPE] = {
UNTIL names = NIL DO
 IF NotExpress[names.first] THEN RETURN[NIL];
FOR list: LIST OF ROPE _ expressMail, list.rest UNTIL list = NIL DO
IF Rope.Equal[names.first, list.first, FALSE] THEN RETURN[list.first];
ENDLOOP;
names _ names.rest;
ENDLOOP;
RETURN[NIL]; };

NotExpress: PROC [name: ROPE] RETURNS [BOOLEAN] = {
FOR list: LIST OF ROPE _ notExpressMail, list.rest UNTIL list = NIL DO
IF Rope.Equal[name, list.first, FALSE] THEN RETURN[TRUE];
ENDLOOP;
RETURN[FALSE]; };

ArpaExpress: PROC [names: LIST OF ROPE] RETURNS [name: ROPE] = {
UNTIL names = NIL DO
FOR list: LIST OF ROPE _ arpaExpressMail, list.rest UNTIL list = NIL DO
IF Rope.Equal[names.first, list.first, FALSE] THEN RETURN[list.first];
ENDLOOP;
names _ names.rest;
ENDLOOP;
RETURN[NIL]; };

DLWithoutUpArrow: PUBLIC PROC [dl: ROPE] RETURNS [valid: BOOL] = {
FOR list: LIST OF ROPE _ noUpArrowDLs, list.rest UNTIL list = NIL DO
IF Rope.Equal[dl, list.first, FALSE] THEN RETURN[TRUE];
ENDLOOP;
RETURN[FALSE];
};



GetQueueForNewMessage: INTERNAL PROC [home: QUEUE, name: ROPE] RETURNS [queue: QUEUE] = {
Find: Queue.ElemProc = {
msgs: RecipBundle _ NARROW[qElem.Value[]];
IF Rope.Equal[msgs.queue.Name[], name, FALSE] THEN {
old _ qElem;
queue _ msgs.queue;
continue _ FALSE; }; };
old: Queue.QElem;
new: RecipBundle;
GVQueue.Enumerate[Find];
IF queue # NIL THEN RETURN;
ExpressQueue.Enumerate[Find];
IF queue # NIL THEN RETURN;
ArpaExpressQueue.Enumerate[Find];
IF queue # NIL THEN RETURN;
HostQueues.Enumerate[Find];
IF queue # NIL THEN RETURN;
SickQueues.Enumerate[Find];
IF queue # NIL THEN RETURN;
EmptyQueues.Enumerate[Find];
IF queue # NIL THEN {
MoveAndLog[from: EmptyQueues, to: home, qElem: old];
RETURN; };
new _ NEW[RecipBundleRep _ [
queue: Queue.Create[name], sent: 0, recv: 0, lastUp: BasicTime.nullGMT]];
EnqueueAndLog[queue: home, qElem: Queue.NewElem[new]];
RETURN[new.queue]; };
PrintItem: PUBLIC ENTRY PROC [item: INT, out: STREAM] = {
descr: Descr;
qElem: Queue.QElem;
[qElem, descr] _ DescrFromHandle[item];
IF descr = NIL THEN {out.PutRope["No item with that handle.\n"]; RETURN};
descr.Print[out: out, form: short];
PrintInibition[qElem, out, NIL]; };
DescrFromHandle: INTERNAL PROC [handle: INT] RETURNS [qe: Queue.QElem, descr: Descr] = {
found: BOOL _ FALSE;
Check: ItemProc = {
qe _ qElem;
descr _ DescrFromElemVal[qElem.Value[]];
IF handle = descr.GetUserHandle[] THEN {found _ TRUE; continue _ FALSE}; };
EnumerateItems[Check];
IF ~found THEN descr _ NIL; };
PrintQueue: PUBLIC ENTRY PROC [name: ROPE, out: STREAM] = {
PrintQueueInner[name, out]; };
PrintQueueInner: INTERNAL PROC [name: ROPE, out: STREAM] = {
queue: QUEUE;
ScanForInfo: Queue.ElemProc = {
msgs: RecipBundle _ NARROW[qElem.Value[]];
IF queue # msgs.queue THEN RETURN [TRUE];
out.PutF[
"\tsent: %G, recv: %G, last up: ", IO.int[msgs.sent], IO.int[msgs.recv]];
IF msgs.lastUp = BasicTime.nullGMT THEN out.PutRope["never"]
ELSE out.Put[IO.time[msgs.lastUp]];
out.PutRope["\n"];
PrintInibition[qElem, out, "\t"];
RETURN[FALSE]; };
PrintVal: Queue.ElemProc = {
value: REF ANY = qElem.Value[];
SELECT ValTypeOfElem[value] FROM
RecipBundleT => {
msgs: RecipBundle = NARROW[value];
out.PutF[
"\t%G:\n\t\tsent: %G, recv: %G, last up: ",
IO.rope[msgs.queue.Name[]], IO.int[msgs.sent], IO.int[msgs.recv]];
IF msgs.lastUp = BasicTime.nullGMT THEN out.PutRope["never"]
ELSE out.Put[IO.time[msgs.lastUp]];
out.PutRope["\n"];
PrintInibition[qElem, out, "\t\t"];
msgs.queue.Enumerate[PrintVal]; };
ENDCASE => {
out.PutRope["\t\t"];
PrintElemVal[value, out];
out.PutChar['\n]; }; };
IF name = NIL THEN {
PrintQueueInner[EmptyQueues.Name[], out];
PrintQueueInner[GVQueue.Name[], out];
PrintQueueInner[ExpressQueue.Name[], out];
PrintQueueInner[ArpaExpressQueue.Name[], out];
PrintQueueInner[HostQueues.Name[], out];
PrintQueueInner[SickQueues.Name[], out];
RETURN; };
queue _ FindQueue[name];
IF queue = NIL THEN {
out.PutRope["Unknown queue: "]; out.PutRope[name]; out.PutRope[".\n"]; RETURN; };
out.PutRope[queue.Name[]];
out.PutRope[":\n"];
EmptyQueues.Enumerate[ScanForInfo];
GVQueue.Enumerate[ScanForInfo];
ExpressQueue.Enumerate[ScanForInfo];
ArpaExpressQueue.Enumerate[ScanForInfo];
HostQueues.Enumerate[ScanForInfo];
SickQueues.Enumerate[ScanForInfo];
queue.Enumerate[PrintVal]; };
FindQueue: INTERNAL PROC [name: ROPE] RETURNS [queue: QUEUE _ NIL] = {
bundle: RecipBundle;
SELECT TRUE FROM
Rope.Equal[name, EmptyQueues.Name[], FALSE] => RETURN[EmptyQueues];
Rope.Equal[name, GVQueue.Name[], FALSE] => RETURN[GVQueue];
Rope.Equal[name, ExpressQueue.Name[], FALSE] => RETURN[ExpressQueue];
Rope.Equal[name, ArpaExpressQueue.Name[], FALSE] => RETURN[ArpaExpressQueue];
Rope.Equal[name, HostQueues.Name[], FALSE] => RETURN[HostQueues];
Rope.Equal[name, SickQueues.Name[], FALSE] => RETURN[SickQueues];
Rope.Equal[name, BadItemQueue.Name[], FALSE] => RETURN[BadItemQueue];
Rope.Equal[name, tempQueue.Name[], FALSE] => RETURN[tempQueue];
ENDCASE;
bundle _ GetBundle[name, FALSE];
IF bundle = NIL THEN RETURN[NIL];
RETURN[bundle.queue]; };
GetBundle: INTERNAL PROC [name: ROPE, create: BOOL] RETURNS [bundle: RecipBundle _ NIL] = {
Find: Queue.ElemProc = {
msgs: RecipBundle _ NARROW[qElem.Value[]];
IF Rope.Equal[msgs.queue.Name[], name, FALSE] THEN {
bundle _ msgs;
continue _ FALSE; }; };
EmptyQueues.Enumerate[Find];
IF bundle # NIL THEN RETURN;
GVQueue.Enumerate[Find];
IF bundle # NIL THEN RETURN;
ExpressQueue.Enumerate[Find];
IF bundle # NIL THEN RETURN;
ArpaExpressQueue.Enumerate[Find];
IF bundle # NIL THEN RETURN;
HostQueues.Enumerate[Find];
IF bundle # NIL THEN RETURN;
SickQueues.Enumerate[Find];
IF bundle # NIL THEN RETURN;
IF ~create THEN RETURN;
bundle _ NEW[RecipBundleRep _ [
queue: Queue.Create[name], sent: 0, recv: 0, lastUp: BasicTime.nullGMT]];
EnqueueAndLog[queue: EmptyQueues, qElem: Queue.NewElem[bundle]]; };
PrintElemVal: PROC [value: REF ANY, out: STREAM] = {
SELECT ValTypeOfElem[value] FROM
DeliveryPkgT, RecipBundleT => out.PutRope[Unparse[value]];
ENDCASE =>
ERROR UserError["Somehow you have tried to print something that isn't a queue."]; };
PrintInibition: PROC [qElem: Queue.QElem, out: STREAM, prefix: ROPE] = {
for: INT;
why: ROPE;
[for, why] _ qElem.Inhibition[];
IF for > 0 THEN out.PutF[
"%GInhibited for %G:%02G because: %G.\n",
IO.rope[prefix], IO.int[for/60], IO.int[for MOD 60], IO.rope[why]]; };
Unparse: PROC [value: REF ANY] RETURNS [ROPE] = {
SELECT TRUE FROM
ISTYPE[value, ItemOnly] => RETURN[NARROW[value, ItemOnly]^.Unparse[]];
ISTYPE[value, DeliveryPkg] => {
pkg: DeliveryPkg = NARROW[value];
r: ROPE _ Rope.Cat[pkg.descr.Unparse[], " for "];
FOR l: LIST OF ROPE _ pkg.recipList, l.rest UNTIL l = NIL DO
r _ Rope.Cat[r, IF l = pkg.recipList THEN NIL ELSE ", ", l.first];
ENDLOOP;
RETURN[r]; };
ISTYPE[value, RecipBundle] =>
RETURN[NARROW[value, RecipBundle].queue.Name[]];
ENDCASE => RETURN["(Unparse ENDCASE)"]; };
StartServer: PUBLIC PROC = TRUSTED {
CheckLists[];
Process.Detach[FORK SendGVMessages[]];
Process.Detach[FORK SendArpaMessages[]];
Process.Detach[FORK Background[]]; };
newMessageArrived: CONDITION _ [timeout: Process.SecondsToTicks[30]];
StartNewMessage: PUBLIC ENTRY PROC [source: ROPE] = {}; -- Hack to hang on ML before reading message from the net. Otherwise we let duplicate messages through because we don't "accept" them after they get onto the disk.
AddNewMessage: PUBLIC ENTRY PROC [descr: Descr, source: ROPE] = {
host: RecipBundle _ GetBundle[source, TRUE];
qElem: Queue.QElem _ Queue.NewElem[NEW[Descr _ descr]];
value: REF ANY _ qElem.Value[];
CheckLists[];
SELECT descr.GetFormat[] FROM
gv => {
from: ROPE _ descr.GetGvSender[];
IF from = NIL THEN {
arpaReversePath, gvSender: ROPE;
gvID: ROPE;
temp: IO.STREAM = descr.RetrieveMsgStream[];
RetrieveReturnTo: SMTPSyntax.GVItemProc = {
IF itemHeader.type = PostMark THEN {
timestamp: GVBasics.Timestamp _ GVProtocol.ReceiveTimestamp[itemStream];
gvID _ GVBasics.RopeFromTimestamp[timestamp]; };
IF itemHeader.type = ReturnTo THEN {
gvSender _ SMTPSyntax.ReceiveRName[itemStream];
from _ gvSender;
continue _ FALSE; }; };
SMTPSyntax.EnumerateGVItems[temp, RetrieveReturnTo];
temp.Close[];
SMTPSupport.Log[verbose, descr.Unparse[], " is ", gvID, "."];
SMTPDescr.SetGvSender[descr, gvSender];
arpaReversePath _ SMTPSyntax.ReversePath[gvSender];
descr.SetArpaReversePath[arpaReversePath]; };
SMTPSupport.Log[verbose, descr.Unparse[], " is from ", from, "."];
IF ~SMTPSupport.AuthorizationCheck[from] OR ~SMTPSupport.CheckHeader[from, descr] THEN {
BEGIN ENABLE SMTPDescr.WrongState => CONTINUE;
SMTPDescr.RemoveRawRecipients[descr];
END;
ConsiderItemDestruction[descr];
RETURN; }; };
arpa => {
arpaReversePath: ROPE;
arpaReversePath _ SMTPDescr.GetArpaReversePath[descr];
arpaReversePath _ SMTPSyntax.UnBlessReturnPath[arpaReversePath];
IF arpaReversePath = NIL THEN {
arpaReversePath _ SMTPDescr.GetGvSender[descr];
arpaReversePath _ SMTPSyntax.UnBlessReturnPath[arpaReversePath];
arpaReversePath _ SMTPSyntax.ReversePath[arpaReversePath]; };
descr.SetArpaReversePath[arpaReversePath];
SMTPSupport.Log[verbose, descr.Unparse[], " is from ", arpaReversePath, "."]; };
ENDCASE => ERROR;
BEGIN ENABLE SMTPDescr.WrongState => CONTINUE; --already processed
redistributed: ROPE;
ProcessRawRecipient: SMTPDescr.RawRecipProc = {
descr: Descr = NARROW[procData, ItemOnly]^;
hostName, userName: ROPE;
[hostName, userName] _ SMTPSyntax.HostAndUser[rawRecipient];
IF hostName = NIL THEN {
hostName _ gvHostName;
IF Rope.Find[userName, "^."] # -1 OR DLWithoutUpArrow[userName] THEN {
IF redistributed = NIL THEN redistributed _ "Redistributed: "
ELSE redistributed _ Rope.Cat[redistributed, ", "];
IF Rope.Find[rawRecipient, "Xerox.ARPA", 0, FALSE] # -1 THEN  
redistributed _ Rope.Cat[redistributed, rawRecipient]
ELSE
redistributed _ Rope.Cat[redistributed, userName];}; };

descr.AddProcessedRecipient[hostName, userName, TRUE]; };
descr.EnumerateRawRecipients[ProcessRawRecipient, value];
IF redistributed # NIL THEN
descr.SetPrecedeMsgText[Rope.Cat[redistributed, "\n", descr.GetPrecedeMsgText[]]];
END;
descr.StoreItemInfo[]; -- update info on disk
descr.EnumerateRecipientHosts[QueueForDelivery, value];
ConsiderItemDestruction[descr]; -- Empty, Crashed after sending to last host
host.recv _ host.recv + 1;
host.lastUp _ BasicTime.Now[]; };
QueueForDelivery: INTERNAL SMTPDescr.HostProc = {
descr: Descr = NARROW[procData, ItemOnly]^;
mainQueue, hostQueue: QUEUE;
queueName: ROPE;
gv: BOOL = Rope.Equal[hostName, gvHostName];
SELECT TRUE FROM
~gv => {
queueName _ hostName;
mainQueue _ HostQueues;
NOTIFY newArpaMessage; };
(queueName _ Express[userNames]) # NIL => {
mainQueue _ ExpressQueue};
(queueName _ ArpaExpress[userNames]) # NIL => {
mainQueue _ ArpaExpressQueue};
ENDCASE => {
queueName _ gvHostName;
mainQueue _ GVQueue;
NOTIFY newGvMessage; };
hostQueue _ GetQueueForNewMessage[mainQueue, queueName];
EnqueueAndLog[queue: hostQueue,
 qElem: Queue.NewElem[NEW[DeliveryPkgRep _ [descr, userNames]]]]; };
newArpaMessage: CONDITION _ [timeout: Process.SecondsToTicks[30]];
GetProcessableHost: ENTRY PROC RETURNS [host: Queue.QElem] = {
DO
host _ HostQueues.GetProcessableElement[];
IF host # NIL THEN { MoveHostToEnd[HostQueues, host]; RETURN; };
WAIT newArpaMessage;
ENDLOOP; };
SendArpaMessages: PROC = {
DO
host: Queue.QElem _ GetProcessableHost[];
recipients: RecipBundle _ NARROW[host.Value[]];
hostQueue: QUEUE _ recipients.queue;
IF ProcessArpaHost[host] THEN LOOP;
IF host.Inhibition[].for > 0 THEN LOOP;
IF hostQueue.IsEmpty[] THEN LOOP; -- Bogus host name
MoveToSick[HostQueues, host, "Didn't make any progress"];
ENDLOOP; };
ProcessArpaHost: PROC [host: Queue.QElem] RETURNS [progress: BOOL] = {
hostStream: SMTPSend.Connection;
recipients: RecipBundle _ NARROW[host.Value[]];
hostQueue: QUEUE _ recipients.queue;
startTime: BasicTime.GMT _ BasicTime.Now[];
BEGIN -- so hostStream and hostQueue will be in scope for EXITS
msg: Queue.QElem;
progress _ FALSE;
IF hostQueue.IsEmpty[] THEN GOTO FlushHostQueue;
hostStream _ SMTPSend.Open[hostQueue.Name[] ! SMTPSend.Failed => {
SELECT withItem FROM
irrelevant, retryLater => {
IF problemWithHost THEN
MoveToSick[HostQueues, host, reason];
GOTO Done; };
returnToSender => { -- there must be a problem with this Host (no item was given)
UNTIL hostQueue.IsEmpty[] DO
qElem: Queue.QElem = hostQueue.GetHead[];
pkg: DeliveryPkg = NARROW[qElem.Value[]];
descr: Descr = pkg.descr;
IF debug THEN SIGNAL LookAtThis;
SMTPSupport.NotifySender[descr, reason];
FinishedWithMsg[queue: hostQueue, pkg: pkg];
ENDLOOP;
IF recipients.recv # 0 THEN GOTO FlushHostQueue; -- Foo@Concord.ms (yetch)
FlushThisHost[queue: HostQueues, value: host.Value[]];
GOTO Done; };
ENDCASE => ERROR; }]; -- putOnBadQueue makes no sense for Open
UNTIL (msg _ GetProcessableElement[hostQueue]) = NIL DO
IF BasicTime.Period[from: startTime, to: BasicTime.Now[]] > 5*60 THEN {
SMTPSupport.Log[important,
 "Already spent more than 5 minutes sending mail to " , Unparse[host.Value[]], "."];
EXIT; };
IF ~SendArpaMsg[hostStream, host, msg] THEN { hostStream.Close[TRUE]; RETURN; };
recipients.sent _ recipients.sent + 1;
recipients.lastUp _ BasicTime.Now[];
progress _ TRUE;
ENDLOOP;
GOTO FlushHostQueue;
EXITS
FlushHostQueue => {
IF hostQueue.IsEmpty[] THEN MoveToEmpty[from: HostQueues, host: host]; };
Done => NULL;
END;
IF hostStream # NIL THEN hostStream.Close[FALSE]; };
LookAtThis: SIGNAL = CODE;
SendArpaMsg: PROC [stream: SMTPSend.Connection, host, msg: Queue.QElem] RETURNS [continue: BOOL _ TRUE] = {
recipients: RecipBundle _ NARROW[host.Value[]];
hostQueue: QUEUE _ recipients.queue;
pkg: DeliveryPkg = NARROW[msg.Value[]];
descr: Descr = pkg.descr;
BEGIN -- so the above vars will be in scope for EXITS
SMTPSend.SendItem[descr, pkg.recipList, stream ! SMTPSend.Failed => {
IF problemWithHost THEN {
MoveToSick[HostQueues, host, reason];
continue _ FALSE; };-- stop the enumeration of SMTP items (stream may be aborted)
SELECT withItem FROM
retryLater => {
IF ~problemWithHost THEN
msg.Inhibit[for: SMTPControl.defaultInhibitTime, why: reason];
GOTO Done; };
returnToSender => {
IF debug THEN SIGNAL LookAtThis;
SMTPSupport.NotifySender[descr, reason];
GOTO RemoveItem; };
putOnBadQueue => {
MoveToBad[queue: hostQueue, msg: msg];
GOTO Done; };
ENDCASE => ERROR; -- shouldn't be irrelevant
}];
GOTO RemoveItem;
EXITS
RemoveItem => {
FinishedWithMsg[queue: hostQueue, pkg: pkg]; };
Done => NULL;
END; };
newGvMessage: CONDITION _ [timeout: Process.SecondsToTicks[30]];
GetGvClump: ENTRY PROC RETURNS [host: Queue.QElem] = {
DO
host _ GVQueue.GetProcessableElement[];
IF host # NIL THEN RETURN;
WAIT newGvMessage;
ENDLOOP; };
SendGVMessages: PROC = {
DO
host: Queue.QElem _ GetGvClump[];
IF ProcessGVQueue[host] THEN LOOP;
IF host.Inhibition[].for > 0 THEN LOOP;
MoveToSick[GVQueue, host, "Didn't make any progress"];
ENDLOOP; };
gvHandle: SMTPGVSend.Connection _ SMTPGVSend.Open[]; -- Only need one
ProcessGVQueue: PROC [host: Queue.QElem] RETURNS [progress: BOOL] = {
recipients: RecipBundle _ NARROW[host.Value[]];
hostQueue: QUEUE _ recipients.queue;
msg: Queue.QElem;
progress _ FALSE;
UNTIL (msg _ GetProcessableElement[hostQueue]) = NIL DO
IF ~SendGVMsg[host, msg] THEN RETURN;
recipients.sent _ recipients.sent + 1;
recipients.lastUp _ BasicTime.Now[];
progress _ TRUE;
ENDLOOP;
IF hostQueue.IsEmpty[] THEN MoveToEmpty[from: GVQueue, host: host];  };
SendGVMsg: PROC [host, msg: Queue.QElem] RETURNS [progress: BOOL _ TRUE] = {
recipients: RecipBundle _ NARROW[host.Value[]];
hostQueue: QUEUE _ recipients.queue;
pkg: DeliveryPkg = NARROW[msg.Value[]];
descr: Descr = pkg.descr;
BEGIN -- so the above vars will be in scope for EXITS
SMTPGVSend.SendItem[descr, pkg.recipList, gvHandle
 ! SMTPGVSend.Failed => {
IF problemWithGV THEN {
MoveToSick[GVQueue, host, reason];
progress _ FALSE; }; -- stop the enumeration of GV item
SELECT withItem FROM
retryLater => {
IF ~problemWithGV THEN
msg.Inhibit[for: SMTPControl.defaultInhibitTime, why: reason];
GOTO Done; };
returnToSender => {
IF debug THEN SIGNAL LookAtThis;
SMTPSupport.NotifySender[descr, reason];
GOTO RemoveItem; };
putOnBadQueue => {
MoveToBad[queue: hostQueue, msg: msg];
GOTO Done; };
ENDCASE => ERROR; -- shouldn't be "irrelevant"
}];
GOTO RemoveItem;
EXITS
RemoveItem => {
FinishedWithMsg[queue: hostQueue, pkg: pkg]; };
Done => NULL;
END; };
Background: ENTRY PROC = {
now: BasicTime.GMT _ BasicTime.Now[];
snooz: CONDITION _ [timeout: Process.SecondsToTicks[1*60]];
DO
WAIT snooz;
CheckLists[];
CheckVM[];
MaybePrintStats[];
ConsiderExpressMail[];
ConsiderOldMessages[];
ConsiderSickHosts[];
ENDLOOP; };

timeVMLastChecked: BasicTime.GMT _ BasicTime.Now[];

timeExpressLastChecked, timeArpaExpressLastChecked, timeNotExpressLastChecked, timeNoUpArrowLastChecked: BasicTime.GMT _ BasicTime.Update[BasicTime.Now[], - checkInterval];
expressStamp, arpaExpressStamp, notExpressStamp, noUpArrowStamp: GVBasics.Timestamp _ GVBasics.oldestTime;
checkInterval: INT = 2*60*60; -- 2 hours
CheckLists: PROC = {
now: BasicTime.GMT _ BasicTime.Now[];
IF BasicTime.Period[from: timeExpressLastChecked, to: now] > checkInterval THEN GetExpressList[];
IF BasicTime.Period[from: timeArpaExpressLastChecked, to: now] > checkInterval THEN GetArpaExpressList[]; 
IF BasicTime.Period[from: timeNotExpressLastChecked, to: now] > checkInterval THEN GetNotExpressList[]; 
IF BasicTime.Period[from: timeNoUpArrowLastChecked, to: now] > checkInterval THEN GetNoUpArrowList[]; 
};
GetExpressList: PROC = TRUSTED {
memberInfo: GVNames.MemberInfo _ [noChange[]];
memberInfo _ GVNames.GetMembers["ExpressMail^.MS", expressStamp];
WITH m: memberInfo SELECT FROM
noChange => timeExpressLastChecked _ BasicTime.Now[];
group => {
timeExpressLastChecked _ BasicTime.Now[];
expressMail _ m.members;
expressStamp _ m.stamp;
SMTPSupport.Log[important, "Updated Express List."]; };
ENDCASE => NULL; };
GetArpaExpressList: PROC = TRUSTED {
memberInfo: GVNames.MemberInfo _ [noChange[]];
memberInfo_ GVNames.GetMembers["ArpaExpressMail^.MS", arpaExpressStamp];
WITH m: memberInfo SELECT FROM
noChange => timeArpaExpressLastChecked _ BasicTime.Now[];
group => {
timeArpaExpressLastChecked _ BasicTime.Now[];
arpaExpressMail _ m.members;
arpaExpressStamp _ m.stamp;
SMTPSupport.Log[important, "Updated Arpa Express List."]; };
ENDCASE => NULL; };

GetNotExpressList: PROC = TRUSTED {
memberInfo: GVNames.MemberInfo _ [noChange[]];
memberInfo_ GVNames.GetMembers["NotArpaExpressMail^.MS", notExpressStamp];
WITH m: memberInfo SELECT FROM
noChange => timeNotExpressLastChecked _ BasicTime.Now[];
group => {
timeNotExpressLastChecked _ BasicTime.Now[];
notExpressMail _ m.members;
notExpressStamp _ m.stamp;
SMTPSupport.Log[important, "Updated Not Express List."]; };
ENDCASE => NULL; };


GetNoUpArrowList: PROC = TRUSTED {
memberInfo: GVNames.MemberInfo _ [noChange[]];
memberInfo_ GVNames.GetMembers["NoUpArrowDLs^.MS", noUpArrowStamp];
WITH m: memberInfo SELECT FROM
noChange => timeNoUpArrowLastChecked _ BasicTime.Now[];
group => {
timeNoUpArrowLastChecked _ BasicTime.Now[];
noUpArrowDLs _ m.members;
noUpArrowStamp _ m.stamp;
SMTPSupport.Log[important, "Updated No Up Arrow DLs."]; };
ENDCASE => NULL; };


CheckVM: PROC = TRUSTED {
now: BasicTime.GMT _ BasicTime.Now[];
date: ROPE _ Convert.RopeFromTime[from: now, start: years, end: days, includeDayOfWeek: TRUE];
pagesAllocated, pagesFreed, pagesInPartition, freeVM: INT;
IF BasicTime.Period[from: timeVMLastChecked, to: now] < 15*60 THEN RETURN;
timeVMLastChecked _ now;
[pagesAllocated, pagesFreed, pagesInPartition] _ VMStatistics.VirtualAllocation[normalVM];
freeVM _ MAX[0, pagesInPartition - pagesAllocated + pagesFreed];
SMTPSupport.Log[important, "Date: ", date, " Free VM is ", Convert.RopeFromInt[freeVM], " pages."];
IF freeVM > 2000 THEN RETURN;
SMTPSupport.Log[important, "\n\n\n**** VM getting low. Here goes a TraceAndSweep.\n\n\n"];
SafeStorage.ReclaimCollectibleObjects[TRUE, TRUE];
[pagesAllocated, pagesFreed, pagesInPartition] _ VMStatistics.VirtualAllocation[normalVM];
freeVM _ MAX[0, pagesInPartition - pagesAllocated + pagesFreed];
SMTPSupport.Log[important, "Free VM is ", Convert.RopeFromInt[freeVM], " pages."]; };


totalGvMsgsSentLastHour: INT _ 0;
totalGvBytesSentLastHour: INT _ 0;
totalArpaMsgsSentLastHour: INT _ 0;
totalArpaBytesSentLastHour: INT _ 0;

totalGvMsgsSentLastDay: INT _ 0;
totalGvBytesSentLastDay: INT _ 0;
totalArpaMsgsSentLastDay: INT _ 0;
totalArpaBytesSentLastDay: INT _ 0;

hourStatsLastChecked: BasicTime.GMT _ BasicTime.Now[];
dayStatsLastChecked: BasicTime.GMT _ BasicTime.Now[];

MaybePrintStats: INTERNAL PROC =  {
now: BasicTime.GMT _ BasicTime.Now[];
hourSecs: INT = 3600;
daySecs: INT = 86400;
hourPeriod: INT _ BasicTime.Period[from: hourStatsLastChecked, to: now];
dayPeriod: INT _ BasicTime.Period[from: dayStatsLastChecked, to: now];
totalGvMsgsSentInHour: INT_0;
totalArpaMsgsSentInHour: INT_0;
totalGvMsgsSentInDay: INT_0;
totalArpaMsgsSentInDay: INT_0;
totalGvBytesSentInHour: INT_0;
totalArpaBytesSentInHour: INT_0;
totalGvBytesSentInDay: INT_0;
totalArpaBytesSentInDay: INT_0;

date: ROPE _ Convert.RopeFromTime[from: now, start: years, end: days, includeDayOfWeek: TRUE];
IF hourPeriod < 3600 THEN RETURN;
hourStatsLastChecked _ now;

SMTPSupport.Log[important, "Date: ", date, ",   Hourly Statistics:  "];

totalGvMsgsSentInHour _ Real.InlineRound[((SMTPGVSend.totalGvMsgsSent - totalGvMsgsSentLastHour)*1.0*hourSecs)/hourPeriod];
totalGvMsgsSentLastHour _ SMTPGVSend.totalGvMsgsSent;

totalGvBytesSentInHour _ Real.InlineRound[((SMTPGVSend.totalGvBytesSent - totalGvBytesSentLastHour)*1.0*hourSecs)/hourPeriod];
totalGvBytesSentLastHour _ SMTPGVSend.totalGvBytesSent;

SMTPSupport.Log[important,  "   Hourly GV bound rate:   ",  Convert.RopeFromInt[totalGvMsgsSentInHour],  " messages,  ",    Convert.RopeFromInt[totalGvBytesSentInHour], " bytes."];

totalArpaMsgsSentInHour _ Real.InlineRound[((SMTPSend.totalArpaMsgsSent - totalArpaMsgsSentLastHour)*1.0*hourSecs)/hourPeriod];
totalArpaMsgsSentLastHour _ SMTPSend.totalArpaMsgsSent;

totalArpaBytesSentInHour _ Real.InlineRound[((SMTPSend.totalArpaBytesSent - totalArpaBytesSentLastHour)*1.0*hourSecs)/hourPeriod];
totalArpaBytesSentLastHour _ SMTPSend.totalArpaBytesSent;

SMTPSupport.Log[important,  "   Hourly Arpa bound rate:   ",  Convert.RopeFromInt[totalArpaMsgsSentInHour],  " messages,  ",    Convert.RopeFromInt[totalArpaBytesSentInHour], " bytes."];

SMTPSupport.Log[important,  "   Arpa queue hosts ",  Convert.RopeFromInt[CountQueueInternal["Arpa"]],  ",  messages ",    Convert.RopeFromInt[CountMessagesInternal["Arpa"]]];

SMTPSupport.Log[important,  "   Sick queue hosts ",  Convert.RopeFromInt[CountQueueInternal["Sick"]],  ",  messages ",    Convert.RopeFromInt[CountMessagesInternal["Sick"]]];

SMTPSupport.Log[important,  "   Express queue hosts ",  Convert.RopeFromInt[CountQueueInternal["Ex"]],  ",  messages ",    Convert.RopeFromInt[CountMessagesInternal["Ex"]]];

SMTPSupport.Log[important,  "   GV queue messages ",  Convert.RopeFromInt[CountMessagesInternal["GV"]]];


IF dayPeriod < daySecs THEN RETURN;
dayStatsLastChecked _ now;


totalGvMsgsSentInDay _ Real.InlineRound[((SMTPGVSend.totalGvMsgsSent - totalGvMsgsSentLastDay)*1.0*daySecs)/dayPeriod];
totalGvMsgsSentLastDay _ SMTPGVSend.totalGvMsgsSent;

totalGvBytesSentInDay _ Real.InlineRound[((SMTPGVSend.totalGvBytesSent - totalGvBytesSentLastDay)*1.0*daySecs)/dayPeriod];
totalGvBytesSentLastDay _ SMTPGVSend.totalGvBytesSent;

SMTPSupport.Log[important,  "   Daily GV bound rate:   ",  Convert.RopeFromInt[totalGvMsgsSentInDay],  " messages,  ",    Convert.RopeFromInt[totalGvBytesSentInDay], " bytes."];

totalArpaMsgsSentInDay _ Real.InlineRound[((SMTPSend.totalArpaMsgsSent - totalArpaMsgsSentLastDay)*1.0*daySecs)/dayPeriod];
totalArpaMsgsSentLastDay _ SMTPSend.totalArpaMsgsSent;

totalArpaBytesSentInDay _ Real.InlineRound[((SMTPSend.totalArpaBytesSent - totalArpaBytesSentLastDay)*1.0*daySecs)/dayPeriod];
totalArpaBytesSentLastDay _ SMTPSend.totalArpaBytesSent;

SMTPSupport.Log[important,  "   Daily Arpa bound rate:   ",  Convert.RopeFromInt[totalArpaMsgsSentInDay],  " messages,  ",    Convert.RopeFromInt[totalArpaBytesSentInDay], " bytes."];


SMTPSupport.Log[important,  "   Total Arpa bound since reboot:   ",  Convert.RopeFromInt[SMTPSend.totalArpaMsgsSent],  " messages,  ",    Convert.RopeFromInt[SMTPSend.totalArpaBytesSent], " bytes."];

SMTPSupport.Log[important,  "   Total GV bound since reboot:   ",  Convert.RopeFromInt[SMTPGVSend.totalGvMsgsSent],  " messages,  ",    Convert.RopeFromInt[SMTPGVSend.totalGvBytesSent], " bytes."];

SMTPSupport.Log[important,  "   Totals since reboot:   ",  Convert.RopeFromInt[SMTPSend.totalArpaMsgsSent+SMTPGVSend.totalGvMsgsSent],  " messages,  ",    Convert.RopeFromInt[SMTPSend.totalArpaBytesSent+SMTPGVSend.totalGvBytesSent], " bytes."];


 };






expressDelay: INT _ 1; -- 1 minute default delay
ConsiderExpressMail: INTERNAL PROC = {
now: BasicTime.Unpacked _ BasicTime.Unpack[BasicTime.Now[]];
host: Queue.QElem;
recipients: RecipBundle;
hostQueue, from, gv: QUEUE;
msg: Queue.QElem;
minutes: INT;
IF ~expressOK THEN RETURN;
IF ~GVQueue.IsEmpty[] THEN RETURN;
IF now.weekday IN [Monday..Friday] AND now.hour IN [8..12+8) THEN RETURN;
host _ ExpressQueue.GetProcessableElement[];
IF host # NIL THEN {
from _ ExpressQueue;
MoveHostToEnd[ExpressQueue, host]; }
ELSE {
host _ ArpaExpressQueue.GetProcessableElement[];
IF host = NIL THEN RETURN;
from _ ArpaExpressQueue;
MoveHostToEnd[ArpaExpressQueue, host]; };
recipients _ NARROW[host.Value[]];
hostQueue _ recipients.queue;
msg _ hostQueue.GetProcessableElement[];
IF hostQueue.IsEmpty[] THEN MoveToEmpty[from: from, host: host]; 
IF msg = NIL THEN { UnlockedMoveToEmpty[from: from, host: host];  RETURN; };
gv _ GetQueueForNewMessage[GVQueue, gvHostName];
MoveAndLog[from: hostQueue, to: gv, qElem: msg];
IF hostQueue.IsEmpty[] THEN UnlockedMoveToEmpty[from: from, host: host]; 
NOTIFY newGvMessage;
SELECT now.hour FROM
12+8 => minutes _ expressDelay + 4; -- 12 messages first hour
12+9 => minutes _ expressDelay + 3; -- 15 messages next hour
12+10 => minutes _ expressDelay + 2; -- 20 messages next hour
ENDCASE => minutes _ expressDelay+1; -- 30 messages/hour => 197 msgs in 8 hrs
IF ~(now.weekday IN[Monday..Friday]) THEN minutes _ expressDelay;
DallyAWhile[minutes]; }; -- (At least 1) Extra minute in main loop
DallyAWhile: INTERNAL PROC [minutes: INT] = {
snooz: CONDITION _ [timeout: Process.SecondsToTicks[minutes*60]];
WAIT snooz; };
ConsiderSickHosts: INTERNAL PROC = {
host: Queue.QElem _ SickQueues.GetProcessableElement[];
IF host # NIL THEN {
recipients: RecipBundle _ NARROW[host.Value[]];
gv: BOOL _ Rope.Equal[recipients.queue.Name[], gvHostName];
target: QUEUE _ IF gv THEN GVQueue ELSE HostQueues;
MoveAndLog[from: SickQueues, to: target, qElem: host];
IF gv THEN NOTIFY newGvMessage ELSE NOTIFY newArpaMessage; }; };

MoveAllSickHosts:  PUBLIC ENTRY PROC = {
Uninhibit: Queue.ElemProc = {
Queue.Uninhibit[qElem, SickQueues];
};
host: Queue.QElem;
SickQueues.Enumerate[Uninhibit];
host _ SickQueues.GetProcessableElement[];
WHILE host # NIL DO
MoveSickHostQueue[host];
host _ SickQueues.GetProcessableElement[];
ENDLOOP;
};


MoveSickHostQueue: INTERNAL PROC[host: Queue.QElem] = {
IF host # NIL THEN {
recipients: RecipBundle _ NARROW[host.Value[]];
gv: BOOL _ Rope.Equal[recipients.queue.Name[], gvHostName];
target: QUEUE _ IF gv THEN GVQueue ELSE HostQueues;
MoveAndLog[from: SickQueues, to: target, qElem: host];
IF gv THEN NOTIFY newGvMessage ELSE NOTIFY newArpaMessage; }; };


FindSickHost: INTERNAL PROC[host: Rope.ROPE] RETURNS[element: Queue.QElem_NIL]= {
Find: Queue.ElemProc = {
msgs: RecipBundle _ NARROW[qElem.Value[]];
IF Rope.Equal[msgs.queue.Name[], host, FALSE] THEN {
Queue.Uninhibit[qElem, SickQueues];
element _ qElem;
continue _ FALSE; }; };
IF host # NIL THEN SickQueues.Enumerate[Find];
};


MoveSickHost: PUBLIC ENTRY PROC[name: Rope.ROPE_ NIL] = {
host: Queue.QElem _ FindSickHost[name];
IF host # NIL THEN {
target: QUEUE _ HostQueues;
MoveAndLog[from: SickQueues, to: target, qElem: host];
NOTIFY newArpaMessage; }; };


CountQueue: PUBLIC ENTRY PROC[name: Rope.ROPE_NIL] RETURNS[n: INT_0]= {
n _ CountQueueInternal[name];
};

CountQueueInternal: INTERNAL PROC[name: Rope.ROPE_NIL] RETURNS[n: INT_0]= {
Count: Queue.ElemProc = {
n _ n+1};
IF name = NIL THEN RETURN[-1];
FindQueue[name].Enumerate[Count];
};

CountMessages: PUBLIC ENTRY PROC[queueName: Rope.ROPE_NIL] RETURNS[n: INT_0]= {
n _ CountMessagesInternal[queueName];
};


CountMessagesInternal:  INTERNAL PROC[name: Rope.ROPE_NIL] RETURNS[n: INT_0]= {
Count: Queue.ElemProc = {
n _ n+1};
CountNested: Queue.ElemProc = {
msgs: RecipBundle _ NARROW[qElem.Value[]];
msgs.queue.Enumerate[Count];
};

IF name = NIL THEN RETURN[-1];

SELECT TRUE FROM
Rope.Equal[name, HostQueues.Name[], FALSE] => HostQueues.Enumerate[CountNested];
Rope.Equal[name, ExpressQueue.Name[], FALSE] => ExpressQueue.Enumerate[CountNested];
Rope.Equal[name, SickQueues.Name[], FALSE] => SickQueues.Enumerate[CountNested];
Rope.Equal[name, GVQueue.Name[], FALSE] => GVQueue.Enumerate[CountNested];
ENDCASE => n _ CountQueueInternal[name];
};


ConsiderOldMessages: INTERNAL PROC = {
now: BasicTime.GMT _ BasicTime.Now[];
host: Queue.QElem _ SickQueues.GetProcessableElement[];
ConsiderExpiration: INTERNAL ItemProc = {
value: REF ANY = qElem.Value[];
pkg: DeliveryPkg = NARROW[qElem.Value[]];
expiryDate: BasicTime.GMT _ SMTPDescr.GetExpiryDate[pkg.descr];
IF BasicTime.Period[from: now, to: expiryDate] < 0 THEN {
reason: ROPE _ "Unable to deliver msg to ";
FOR loosers: LIST OF ROPE _ pkg.recipList, loosers.rest UNTIL loosers = NIL DO
reason _ Rope.Cat[reason, IF loosers = pkg.recipList THEN NIL ELSE ", ", loosers.first];
ENDLOOP;
reason _ Rope.Cat[reason, " at ", queue.Name[], " within a reasonable amount of time."];
MoveAndLog[from: queue, to: tempQueue, qElem: qElem];
SendItBack[queue: queue, qElem: qElem];
RETURN[FALSE]; }; };
IF ~GVQueue.IsEmpty[] THEN RETURN;
IF ~HostQueues.IsEmpty[] THEN RETURN;
EnumerateSickPkgs[ConsiderExpiration]; };
SendItBack: INTERNAL PROC [queue: QUEUE, qElem: Queue.QElem] = {
pkg: DeliveryPkg = NARROW[qElem.Value[]];
reason: ROPE _ "Unable to deliver msg to ";
FOR loosers: LIST OF ROPE _ pkg.recipList, loosers.rest UNTIL loosers = NIL DO
reason _ Rope.Cat[reason, IF loosers = pkg.recipList THEN NIL ELSE ", ", loosers.first];
ENDLOOP;
reason _ Rope.Cat[reason, " at ", queue.Name[], " within a reasonable amount of time."];
SMTPSupport.NotifySender[pkg.descr, reason];
MoveAndLog[from: tempQueue, to: queue, qElem: qElem];
InternalFinishedWithMsg[queue: queue, pkg: pkg]; };
UserError: PUBLIC ERROR [reason: ROPE] = CODE;
Failed: ERROR [why: ErrorCode, reason: ROPE] = CODE;
ErrorCode: TYPE = {lockNotObtained, notOnQueue};
DescrFromElemVal: PROC [elemVal: REF ANY] RETURNS [Descr] = {
SELECT ValTypeOfElem[elemVal] FROM
ItemOnlyT => RETURN[NARROW[elemVal, ItemOnly]^];
DeliveryPkgT => RETURN[NARROW[elemVal, DeliveryPkg].descr];
ENDCASE => ERROR; };
ItemProc: TYPE = PROC [queue: QUEUE, qElem: Queue.QElem, procData: REF ANY _ NIL] RETURNS [continue: BOOL _ TRUE];
EnumerateSickPkgs: INTERNAL PROC [proc: ItemProc, data: REF ANY _ NIL] = {
continueOverall: BOOL;
queue: QUEUE;
ScanQueue: Queue.ElemProc = {
continueOverall _ proc[queue, qElem, data];
RETURN[continueOverall]; };
ScanHostQueue: Queue.ElemProc = {
queue _ NARROW[qElem.Value[], RecipBundle].queue;
queue.Enumerate[ScanQueue];
RETURN[continueOverall]; };
SickQueues.Enumerate[ScanHostQueue]; };
EnumerateItems: INTERNAL PROC [proc: ItemProc, data: REF ANY _ NIL] = {
continueOverall: BOOL;
queue: QUEUE;
ScanQueue: Queue.ElemProc = {
continueOverall _ proc[queue, qElem, data];
RETURN[continueOverall]; };
ScanHostQueue: Queue.ElemProc = {
queue _ NARROW[qElem.Value[], RecipBundle].queue;
queue.Enumerate[ScanQueue];
RETURN[continueOverall]; };
IF ~continueOverall THEN RETURN;
GVQueue.Enumerate[ScanHostQueue];
IF ~continueOverall THEN RETURN;
ExpressQueue.Enumerate[ScanHostQueue];
IF ~continueOverall THEN RETURN;
HostQueues.Enumerate[ScanHostQueue];
IF ~continueOverall THEN RETURN;
SickQueues.Enumerate[ScanHostQueue];
IF ~continueOverall THEN RETURN;
queue _ tempQueue;
tempQueue.Enumerate[ScanQueue, data];
queue _ BadItemQueue;
BadItemQueue.Enumerate[ScanQueue, data]; };
QueueProc: TYPE = PROC [queue: QUEUE, procData: REF ANY _ NIL] RETURNS [continue: BOOL _ TRUE];
EnumerateQueues: INTERNAL PROC [proc: QueueProc, data: REF ANY _ NIL] = {
continueOverall: BOOL _ TRUE;
ScanHostQueue: Queue.ElemProc = {
queue: QUEUE _ NARROW[qElem.Value[], RecipBundle].queue;
continueOverall _ proc[queue, data];
RETURN[continueOverall]; };
GVQueue.Enumerate[ScanHostQueue];
IF ~continueOverall THEN RETURN;
ExpressQueue.Enumerate[ScanHostQueue];
IF ~continueOverall THEN RETURN;
ArpaExpressQueue.Enumerate[ScanHostQueue];
IF ~continueOverall THEN RETURN;
HostQueues.Enumerate[ScanHostQueue];
IF ~continueOverall THEN RETURN;
SickQueues.Enumerate[ScanHostQueue];
IF ~continueOverall THEN RETURN;
IF ~proc[tempQueue, data] THEN RETURN;
IF ~proc[BadItemQueue, data] THEN RETURN; };
GetProcessableElement: ENTRY PROC [queue: QUEUE] RETURNS [qElem: Queue.QElem] = {
qElem _ queue.GetProcessableElement[];
IF qElem = NIL THEN RETURN;
queue.Dequeue[qElem.Value[]];
queue.Enqueue[qElem]; };
MoveHostToEnd: INTERNAL PROC [queue: QUEUE, qElem: Queue.QElem] = {
queue.Dequeue[qElem.Value[]];
queue.Enqueue[qElem]; };
MoveToEmpty: ENTRY PROC [from: QUEUE, host: Queue.QElem] = {
MoveAndLog[from: from, to: EmptyQueues, qElem: host]; };
UnlockedMoveToEmpty: INTERNAL PROC [from: QUEUE, host: Queue.QElem] = {
MoveAndLog[from: from, to: EmptyQueues, qElem: host]; };
MoveToSick: ENTRY PROC [from: QUEUE, host: Queue.QElem, reason: ROPE] = {
host.Inhibit[for: SMTPControl.defaultInhibitTime, why: reason];
MoveAndLog[from: from, to: SickQueues, qElem: host]; };
MoveToBad: ENTRY PROC [queue: QUEUE, msg: Queue.QElem] = {
DequeueAndLog[queue: queue, value: msg.Value[]];
EnqueueAndLog[queue: BadItemQueue, qElem: msg]; };
FlushThisHost: ENTRY PROC [queue: QUEUE, value: REF ANY] = {
DequeueAndLog[queue: queue, value: value]; };
FinishedWithMsg: ENTRY PROC [queue: QUEUE, pkg: DeliveryPkg] = {
InternalFinishedWithMsg[queue, pkg]; };
InternalFinishedWithMsg: INTERNAL PROC [queue: QUEUE, pkg: DeliveryPkg] = {
pkg.descr.RemoveRecipientHost[queue.Name[]];
DequeueAndLog[queue: queue, value: pkg];
ConsiderItemDestruction[descr: pkg.descr]; };
LockedMoveAndLog: ENTRY PROC [from, to: QUEUE, qElem: Queue.QElem] = {
MoveAndLog[from: from, to: to, qElem: qElem]; };
MoveAndLog: INTERNAL PROC [from, to: QUEUE, qElem: Queue.QElem] = {
from.Dequeue[qElem.Value[]];
to.Enqueue[qElem];
SMTPSupport.Log[verbose,
 Unparse[qElem.Value[]], " moved from ", from.Name[], " to ", to.Name[], "."]; };
EnqueueAndLog: INTERNAL PROC [queue: QUEUE, qElem: Queue.QElem] = {
queue.Enqueue[qElem];
SMTPSupport.Log[verbose,
 Unparse[qElem.Value[]], " added to ", queue.Name[], "."]; };
DequeueAndLog: INTERNAL PROC [queue: QUEUE, value: REF ANY] = {
val: ROPE = Unparse[value];
queue.Dequeue[value];
SMTPSupport.Log[verbose, val, " removed from ", queue.Name[], "."]; };
ValTypeOfQueue: PROC [queue: QUEUE] RETURNS [ElemValType] = {
RETURN[SELECT queue FROM
tempQueue, BadItemQueue => DeliveryPkgT,
EmptyQueues, GVQueue, ExpressQueue, HostQueues, SickQueues => RecipBundleT,
ENDCASE => DeliveryPkgT ]; };
ValTypeOfElem: PROC [value: REF ANY] RETURNS [ElemValType] = {
SELECT TRUE FROM
ISTYPE[value, DeliveryPkg] => RETURN[DeliveryPkgT];
ISTYPE[value, RecipBundle] => RETURN[RecipBundleT];
ENDCASE => ERROR; };
ElemValType: TYPE = {ItemOnlyT, DeliveryPkgT, RecipBundleT};
ValTypeNames: ARRAY ElemValType OF ROPE = [
"Somebody is confused",
Rope.Cat[
"DeliveryPkg (from ", ", an Host queue, or ", BadItemQueue.Name[], ")"],
Rope.Cat["Host queue (from Empty, GV, Ex, ARPA, or Sick)"] ];
ConsiderItemDestruction: INTERNAL PROC [descr: Descr] = {
queues: LIST OF QUEUE _ NIL;
itemPresent: BOOL _ FALSE;
onQueue: QUEUE;

CollectQueues: QueueProc = {queues _ CONS[queue, queues]; };
EnumerateQueues[CollectQueues];
[itemPresent, onQueue] _ ItemIsOn[descr.GetUserHandle[], queues];
IF itemPresent THEN {
IF ~descr.MoreRecipients[] AND onQueue # BadItemQueue THEN -- queue corruption
SMTPSupport.Log[important,
 "There are no more recipients in the item descriptor for item",
 descr.Unparse[],
 ", but there is a reference to it on ", onQueue.Name[], 
 ".\nThis should not have occurred; the demons should discard it."]; }
ELSE { -- item not present on any queues
IF descr.MoreRecipients[] THEN {
qElem: Queue.QElem = Queue.NewElem[NEW[DeliveryPkgRep _
 [descr: descr, recipList: NIL]]];
EnqueueAndLog[queue: BadItemQueue, qElem: qElem];
SMTPSupport.Log[ATTENTION,
 "There are more recipients in the item descriptor for item ",
 descr.Unparse[],
 ", though there is no reference to it on any queue.\n",
 "This should not have occurred. Have placed a deliveryPkg on ",
 BadItemQueue.Name[], "."]; }
ELSE { descr.Destroy[]; }; }; };
ItemIsOn: INTERNAL PROC [handle: INT, queueList: LIST OF QUEUE] RETURNS [itemPresent: BOOL, onQueue: QUEUE] = {
itemPresent _ FALSE;
FOR qList: LIST OF QUEUE _ queueList, qList.rest UNTIL qList = NIL DO
onQueue _ qList.first;
IF RetrieveElemVal[onQueue, handle, FALSE] # NIL THEN {
itemPresent _ TRUE;
EXIT; };
ENDLOOP; };
RetrieveElemVal: PUBLIC PROC [queue: QUEUE, handle: INT, errorIfNotFound: BOOL _ TRUE] RETURNS [value: REF ANY _ NIL] = {
SELECT ValTypeOfQueue[queue] FROM
DeliveryPkgT => {
Find: Queue.ElemProc = {
IF handle = SMTPDescr.GetUserHandle[NARROW[qElem.Value[], DeliveryPkg].descr] THEN {value _ qElem.Value[]; continue _ FALSE}; };
queue.Enumerate[Find]; };
RecipBundleT =>
ERROR UserError[IO.PutFR["You have asked the queue module to retrieve item #%g from HostQueues, which doesn't directly contain items (possibly a code bug). Use HostQueue.", IO.int[handle]]];
ENDCASE => ERROR;
IF value = NIL AND errorIfNotFound THEN {
reason: ROPE = IO.PutFR[
"Msg #%g not found on %g.", IO.int[handle], IO.rope[queue.Name[]]];
ERROR UserError[reason]; };
}; -- end RetrieveElemVal
END.
.SMTPQueueImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
DCraft, December 21, 1983 9:02 pm
Taft, February 4, 1984 4:30:19 pm PST
Hal Murray May 29, 1985 2:17:17 am PDT
John Larson, August 2, 1987 4:20:36 pm PDT
Queue elements (which must be REFs) are DeliveryPkgs or RecipBundles.
The Queues (Names are in ValTypeNames too)
Note: The names of all sub-queues must be unique
Special Host Names and such
Policy controls
Not currently in use yet. Try for an old one.
Doesn't exist yet. Make it.
Fish Sender out of body of msg, but not if ReturnToSender has already set one up.
Beware of loops if you can't return a message to the original sender.
--  Show old name if used
on Open probably means the host name is unknown; all items should be returned
Reject the whole list...
Info for lists
IF now.hour = 12+11 THEN RETURN; -- Archiver and RegPurger
This heuristic is a hack. For easy messages it's too slow. For nasty ones, GV still gets swamped.
IF ~HostQueues.IsEmpty[] THEN RETURN;
Miscellaneous
Will happily queue wrong value type on a queue.
Check all item queues (excluding InSystemQueue) to determine if descr is on any of them. If so, the item should be retained, else destroyed unless there are further recipients in the descriptor (in which case there is some error so log an ATTENTION msg and place on BadItemQueue). Also log an error if the descr appears on some queue but has no further recipients.
The alternative to this (and the way I first implemented it) is to check only if there are no further recipients in the recipient list field of the Descr, and assume that if there aren't then the item isn't on any pkg queue. If all of the code was right, and users could never confuse the queue system, this would be the better choice because all of the queues wouldn't have to be searched. However, we don't want pkgs on queues pointing to a destroyed item, and this is a server so we must try to act intelligently in the face of corruptions...
Find the value of the element on queue with the given user handle. Value is NIL if handle not found on queue.
�Ê-
–

"cedar" style˜
headš
œ™Icodešœ
Ïm
œ1™<Lš
œ!™!Lš
œ%™%Lš
œ&™&L™*
code2š
Ïk	˜	Mšœ
žœžœ2˜FMšœžœ˜*Mšœ	žœ,˜:Mšœžœ˜'Mšœžœ˜$Mšžœ
žœ8žœ˜NMšœžœ˜'Mšœžœ˜Mšœžœžœ˜$Jšœžœ˜.Jšžœ
žœ˜Jšœ
žœ˜'M˜Mšœžœožœ*˜¦
Mšœžœ˜'Mšœ
žœ…˜”MšœžœI˜YMšœ
žœ˜Mšœ	žœT˜bMšœžœ6˜GMšœžœ[˜k——šÐln
œžœ
ž˜Mšžœ4žœ~˜»
Mšžœ˜Mš
ž˜Mšœžœ˜Mšžœžœžœ
˜Mšžœžœžœ
žœ
˜Mšžœžœ	žœ
˜M™EMšœ
žœžœÏc1˜MMšœ
žœžœ G˜oMšœžœžœžœ
žœ
žœ˜EMšœ
žœžœ -˜Ušœžœžœ˜Mšœžœ
˜
Mšœžœ˜Mšœžœ˜—š
œ*™*M™0MšÏnœžœ ˜DMš¡œžœ Ðci
˜=Mš¡œžœ ¢
˜BMš¡œžœ ¢
˜JMš¡
œžœ ¢
˜BMš¡
œžœ ¢
˜BMš¡œžœ ˜CMšœžœ ˜A—™Mšœžœ )˜IMšœžœ
˜"Mšœ
žœ
žœ
žœ
˜Mšœžœ˜*Mšœžœ
žœ
žœ
˜Mšœžœ
žœ
žœ
˜M˜MšÐmtœž˜"M˜—™Mšœžœžœ
˜—Mšœžœžœ
˜Mš¡œžœ
žœ
žœžœ
žœ
žœžœ˜MMš¡œžœ
žœžœ˜8š¡œžœ	žœ
žœ
žœžœžœ˜<Mšžœ	žœ
ž˜š	œ
žœžœ
žœ
žœ˜-š
žœžœ
žœ
žœžœžœ
ž˜CMšžœ%žœžœ
žœ
˜FMšžœ
˜—Mš
œ˜Mšžœ
˜—Mšžœ
žœ˜M˜—š
¡
œžœžœžœžœ˜3š
žœžœ
žœ
žœžœžœ
ž˜Fš
žœžœžœ
žœ
žœ˜9Mšžœ
˜—Mšžœ
žœ˜—M˜—š¡œžœ	žœ
žœ
žœžœžœ˜@šžœ	žœ
ž˜š
žœžœ
žœ
žœžœžœ
ž˜GMšžœ%žœžœ
žœ
˜FMšžœ
˜—Mš
œ˜Mšžœ
˜—Mšžœ
žœ˜M˜—š
¡œžœžœžœ	žœ˜Bš
žœžœ
žœ
žœžœžœ
ž˜DMš
žœžœžœ
žœ
žœ˜7Mšžœ
˜—Mšžœ
žœ˜Mš
œ˜M˜M˜M˜—š¡œžœ
žœžœžœžœ	žœ˜Yš¡œ˜Mšœžœ˜*šžœ%žœžœ˜4Mš
œ˜Mš
œ˜Mšœžœ˜——Mš
œ˜Mš
œ˜M˜Mšžœ	žœ
žœ
žœ
˜M˜Mšžœ	žœ
žœ
žœ
˜M˜!Mšžœ	žœ
žœ
žœ
˜M˜Mšžœ	žœ
žœ
žœ
˜Mš
œ˜Mšžœ	žœ
žœ
žœ
˜Mš
œ-™-Mš
œ˜šžœ	žœ
žœ˜Mš
œ4˜4Mšžœ˜
—Mš
œ™šœžœ˜Mš
œI˜I—Mš
œ6˜6Mšžœ˜—š¡	œžœ
žœ
žœžœžœ˜9Mš
œ
˜
Mš
œ˜Mš
œ'˜'Mšžœ	žœ
žœ.žœ˜IMš
œ#˜#Mšœžœ˜#—š
¡œžœ
žœ
žœžœ$˜XMšœžœžœ
˜š¡œ˜M˜Mš
œ(˜(Mšžœ žœ
žœ
žœ˜K—M˜Mšžœžœ	žœ˜—š¡
œžœ
žœ
žœžœžœ˜;Mš
œ˜—š
¡œžœ
žœžœžœ˜<Mšœžœ
˜
š¡œ˜Mšœžœ˜*Mšžœžœ
žœžœ˜)š
œ	˜	Mšœ#žœžœ˜I—Mšžœ!žœ˜<Mšžœ	žœ˜#Mš
œ˜Mš
œ!˜!Mšžœ
žœ˜—š¡œ˜Mšœžœ
žœ˜šžœž˜ š
œ˜Mšœžœ˜"š
œ	˜	Mš
œ+˜+Mšžœžœžœ˜B—Mšžœ!žœ˜<Mšžœ	žœ˜#Mš
œ˜Mš
œ#˜#Mš
œ"˜"—šžœ˜Mš
œ˜Mš
œ˜Mš
œ˜———šžœžœ
žœ˜Mš
œ)˜)Mš
œ%˜%Mš
œ*˜*Mš
œ.˜.Mš
œ(˜(Mš
œ(˜(Mšžœ˜
—Mš
œ˜šžœ	žœ
žœ˜MšœGžœ˜Q—Mš
œ˜M˜Mš
œ#˜#Mš
œ˜Mš
œ$˜$Mš
œ(˜(Mš
œ"˜"Mš
œ"˜"Mš
œ˜—š¡	œžœ
žœžœžœ	žœžœ˜FMš
œ˜šžœ
žœ
ž˜Mšœ%žœžœ˜CMšœ!žœžœ
˜;Mšœ&žœžœ˜EMšœ*žœžœ˜MMšœ$žœžœ
˜AMšœ$žœžœ
˜AMšœ&žœžœ˜EMšœ#žœžœ˜?Mšžœ
˜—Mšœžœ˜ Mš
žœ
žœ
žœ
žœ
žœ˜!Mšžœ˜—š¡	œžœ
žœžœ
žœžœžœ˜[š¡œ˜Mšœžœ˜*šžœ%žœžœ˜4Mš
œ˜Mšœžœ˜——Mš
œ˜Mšžœ
žœ
žœ
žœ
˜M˜Mšžœ
žœ
žœ
žœ
˜M˜Mšžœ
žœ
žœ
žœ
˜M˜!Mšžœ
žœ
žœ
žœ
˜M˜Mšžœ
žœ
žœ
žœ
˜Mš
œ˜Mšžœ
žœ
žœ
žœ
˜Mšžœ	žœ
žœ
˜šœ	žœ˜Mš
œI˜I—Mš
œC˜C—š
¡œžœ	žœ
žœžœ˜4šžœž˜ Mš
œ:˜:šžœ˜
MšžœO˜T———š¡œžœžœ
žœ˜HMšœžœ
˜	Mšœžœ
˜
Mš
œ ˜ šžœ	žœ
˜Mš
œ)˜)Mš
žœžœžœ	žœžœ˜F——š¡œžœ	žœ
žœžœžœ˜1šžœ
žœ
ž˜Mšžœžœ
žœ˜Fšžœ˜Mšœžœ˜!Mšœžœ*˜1š
žœžœ
žœ
žœžœžœ
ž˜<Mš	œžœžœ
žœ
žœ˜BMšžœ
˜—Mšžœ˜
—šžœ˜Mšžœ
žœ#˜0—Mšžœžœ˜*——š¡œžœ
žœžœ˜$Mš
œ
˜
Mšœžœ˜&Mšœžœ˜(Mšœžœ˜%—Mšœž	œ)˜EMš¡œžœ
žœ
žœ
žœ £
˜Û
š
¡
œžœ
žœ
žœžœ˜AMšœ&žœ˜,Mšœ#žœ˜7Mšœžœ
žœ˜Mš
œ
˜
šžœž˜š
œ˜Mšœžœ˜!Mš
œQ™QM™Ešžœžœ
žœ˜Mšœžœ
˜ Mšœžœ
˜Mšœžœ
žœ˜,š¡œ˜+šžœžœ˜$Mš
œH˜HM˜0—šžœžœ˜$Mš
œ/˜/Mš
œ˜Mšœžœ˜——M˜4M˜
Mš
œ=˜=Mš
œ'˜'Mš
œ3˜3Mš
œ-˜-—Mš
œB˜Bšžœ'žœ'žœ˜XMšžœ
žœžœ
˜.Mš
œ%˜%Mšžœ
˜Mš
œ˜Mšžœ˜
——š
œ	˜	Mšœžœ
˜Mš
œ6˜6Mš
œ@˜@šžœžœ
žœ˜Mš
œ/˜/Mš
œ@˜@Mš
œ=˜=—Mš
œ*˜*Mš
œP˜P—Mšžœžœ
˜—Mšžœ
žœžœ ˜BMšœžœ
˜š¡œ˜/Mšœžœ˜+Mšœžœ
˜M˜<šžœžœ
žœ˜Mš
œ˜šžœ žœžœ˜FMšžœžœ
žœ"˜=Mšžœ/˜3Mš
 ™šžœ*žœžœ˜>Mš
œ5˜5—š
ž˜Mš
œ8˜8———Mšœ0žœ˜9—Mš
œ9˜9šžœžœ
ž˜Mš
œR˜R—Mšžœ
˜Mšœ ˜-Mš
œ7˜7Mšœ  ,˜LM˜Mš
œ!˜!—š¡œžœ˜1Mšœžœ˜+Mšœžœ
˜Mšœžœ
˜Mšœžœ$˜,šžœ
žœ
ž˜š
œ˜Mš
œ˜Mš
œ˜Mšžœ˜—šœ#žœ˜+Mš
œ˜—šœ'žœ˜/Mš
œ˜—šžœ˜Mš
œ˜Mš
œ˜Mšžœ˜——Mš
œ8˜8Mšœ6žœ+˜d—Mšœž	œ)˜Bš¡œžœ
žœ
žœ˜>š
ž˜Mš
œ*˜*Mšžœžœ
žœ$žœ˜@Mšžœ˜Mšžœ˜——š¡œžœ˜š
ž˜Mš
œ)˜)Mšœžœ˜/Mšœžœ˜$Mšžœžœ
žœ
˜#Mšžœžœ
žœ
˜'Mšžœžœ
žœ ˜4Mš
œ9˜9Mšžœ˜——š¡œžœžœžœ˜FMš
œ ˜ Mšœžœ˜/Mšœžœ˜$Mšœžœ˜+Mšžœ
 9˜?Mš
œ˜Mšœžœ
˜Mšžœžœ
žœ˜0š
œB˜Bšžœ
ž˜š
œ˜šžœž˜Mš
œ%˜%—Mšžœ	˜
—šœ =˜QM™MM™šžœž˜Mš
œ)˜)Mšœžœ˜)Mš
œ˜Mšžœžœ
žœ˜ Mš
œ(˜(Mš
œ,˜,Mšžœ
˜—Mšžœžœ
žœ ˜JMš
œ6˜6Mšžœ	˜
—Mšžœžœ (˜>——šžœ,žœ
ž˜7šžœ?žœ˜GMš
œo˜oMšžœ˜—Mšžœ%žœžœžœ˜PMš
œ&˜&Mš
œ$˜$Mšœžœ
˜Mšžœ
˜—Mšžœ˜š
ž˜š
œ˜Mšžœžœ.˜I—Mšœžœ
˜
—Mšžœ
˜Mšžœžœ
žœžœ˜4—Mš¡
œžœžœ
˜š
¡œžœ7žœžœžœ˜kMšœžœ˜/Mšœžœ˜$Mšœžœ˜'Mš
œ˜šžœ
 /˜5š
œE˜Ešžœžœ˜Mš
œ%˜%Mšœžœ =˜Q—šžœ
ž˜˜šžœž˜Mš
œ>˜>—Mšžœ	˜
—˜Mšžœžœ
žœ˜ M˜(Mšžœ˜—˜Mš
œ&˜&Mšžœ	˜
—Mšžœžœ ˜,—Mš
œ˜—Mšžœ˜š
ž˜š
œ˜Mš
œ/˜/—Mšœžœ
˜
—Mšžœ˜——Mšœž	œ)˜@š¡
œžœ
žœ
žœ˜6š
ž˜Mš
œ'˜'Mšžœžœ
žœ
žœ
˜Mšžœ˜Mšžœ˜——š¡œžœ˜š
ž˜Mš
œ!˜!Mšžœžœ
žœ
˜"Mšžœžœ
žœ
˜'Mš
œ6˜6Mšžœ˜——Mšœ5 ˜Eš¡œžœžœžœ˜EMšœžœ˜/Mšœžœ˜$Mš
œ˜Mšœžœ
˜šžœ,žœ
ž˜7Mšžœžœ
žœ
˜%Mš
œ&˜&Mš
œ$˜$Mšœžœ
˜Mšžœ
˜—Mšžœžœ,˜G—š
¡	œžœžœžœžœ˜LMšœžœ˜/Mšœžœ˜$Mšœžœ˜'Mš
œ˜šžœ
 /˜5š
œL˜Lšžœžœ˜Mš
œ"˜"Mšœžœ "˜7—šžœ
ž˜˜šžœž˜Mš
œ>˜>Mšžœ	˜
——˜Mšžœžœ
žœ˜ Mš
œ(˜(Mšžœ˜—˜Mš
œ&˜&Mšžœ	˜
—Mšžœžœ ˜.—Mš
œ˜—Mšžœ˜š
ž˜š
œ˜Mš
œ/˜/—Mšœžœ
˜
—Mšžœ˜——š¡
œžœ
žœ˜Mšœžœ˜%Mšœž	œ+˜;š
ž˜Mšžœ˜M˜
M˜
M˜M˜M˜M˜Mšžœ˜—M˜—Mšœžœ˜3M˜š
œ™MšœO£œžœ6˜¬
Mšœ1£œ+˜jMšœžœ 
˜(—š¡
œžœ˜Mšœžœ˜%MšžœIžœ˜aMšžœMžœ˜jMšžœLžœ˜hMšÑkmt£K¤£˜fMš
œ˜—š¡œžœžœ˜ Mš
œ.˜.Mš
œA˜Ašžœžœ
ž˜Mš
œ5˜5˜
Mš
œ)˜)M˜M˜Jš
œ7˜7—Mšžœžœ˜——š¡œžœžœ˜$Mš
œ.˜.Mš
œH˜Hšžœžœ
ž˜Mš
œ9˜9˜
Mš
œ-˜-Mš
œ˜Mš
œ˜Jš
œ<˜<—Mšžœžœ˜M˜——š¡œžœžœ˜#Mš
œ.˜.Mš
œJ˜Jšžœžœ
ž˜Mš
œ8˜8˜
Mš
œ,˜,Mš
œ˜Mš
œ˜Jš
œ;˜;—Mšžœžœ˜M˜M˜——šÑmntœžœžœ˜"Mš
œ.˜.Mšœ £œ£œ˜Cšžœžœ
ž˜Mšœ£œ˜7˜
Mš£œ˜+Mš£œ
˜Mš£œ˜Jšœ$£œ˜:—Mšžœžœ˜M˜M˜——š¡œžœžœ˜Mšœžœ˜%MšœžœNžœ˜^Mšœ6žœ
˜:Mšžœ<žœ
žœ
˜JMš
œ˜Jš
œZ˜ZJšœ	žœ4˜@Jš
œc˜cJšžœžœ
žœ
˜Jš
œZ˜ZJšœ&žœžœ˜2Jš
œZ˜ZJšœ	žœ4˜@Jš
œU˜UJ˜J˜—Jšœžœ˜!Jšœžœ˜"Jšœžœ˜#Jšœžœ˜$J˜Jšœžœ˜ Jšœžœ˜!Jšœžœ˜"Jšœžœ˜#J˜Mšœ žœ˜6Mšœžœ˜5M˜š¡œž
œ˜#Mšœžœ˜%Mšœ
žœ˜Mšœ	žœ	˜Mšœžœ9˜HMšœžœ8˜FMšœžœ˜Mšœžœ˜Mšœžœ˜Mšœžœ˜Mšœžœ˜Mšœžœ˜ Mšœžœ˜Mšœžœ˜M˜MšœžœNžœ˜^Mšžœžœ
žœ
˜!Mš
œ˜M˜Jš
œG˜GM˜Mš
œ{˜{Mš
œ5˜5M˜Mš
œ~˜~Mš
œ7˜7M˜Jš
ϫ
˜´
J˜Mš
œ˜Mš
œ7˜7M˜Mš
œ‚
˜‚
Mš
œ9˜9J˜Jš
ϼ
˜º
J˜Jš
Ϩ
˜®
J˜Jš
Ϩ
˜®
J˜Jš
œ­
˜­
J˜Jš
œh˜hJ˜J˜Mšžœžœ
žœ
˜#Mš
œ˜J˜J˜Mš
œw˜wMš
œ4˜4M˜Mš
œz˜zMš
œ6˜6M˜Jš
ϱ
˜±
M˜Mš
œ{˜{Mš
œ6˜6M˜Mš
œ~˜~Mš
œ8˜8J˜Jš
œ·
˜·
J˜J˜Jš
ς
˜Ç
J˜Jš
ρ
˜Å
J˜Jš
ϙ
˜ô
J˜J˜Jš
œ˜J˜J˜J˜J˜J˜J˜—Jšœžœ ˜0š¡œžœ
žœ˜&Mš
œ<˜<Mš
œ˜Mš
œ˜Mšœžœ
˜Mš
œ˜Mšœ	žœ
˜
Mšžœžœ
žœ
˜Mšžœžœ
žœ
˜"Mšžœ
žœžœ
žœžœ
žœ
˜IMšžœžœ
žœ ™:Mš
œ,˜,šžœžœ
žœ˜Mš
œ˜Mš
œ$˜$—šžœ˜Mš
œ0˜0Mšžœžœ
žœ
žœ
˜Mš
œ˜Mš
œ)˜)—Mšœ
žœ˜"Mš
œ˜Mš
œ(˜(Mšžœžœ&˜AMšžœžœ
žœ1žœ˜LMš
œ0˜0Mš
œ0˜0Mšžœžœ.˜IMšžœ˜M™ašžœ
ž˜Mšœ$ ˜=Mšœ$ ˜<Mšœ% ˜=Mšžœ (˜M—Mšžœžœžœ˜AMšœ )˜B—š¡œžœ
žœžœ˜-Mšœž	œ1˜AMšžœ
˜—š¡œžœ
žœ˜$Mš
œ7˜7Mšžœžœ
žœ
™%šžœžœ
žœ˜Mšœžœ˜/Mšœžœ3˜;Mš	œžœžœžœ	žœ˜3Mš
œ6˜6Mš
žœžœ
žœžœ
žœ˜@M˜——š¡œžœ
žœ
žœ˜(š¡	œ˜Mš
œ#˜#Mš
œ˜—Jš
œ˜Mš
œ ˜ Jš
œ*˜*šžœžœ
ž˜Jš
œ˜Jš
œ*˜*Jšžœ
˜—š
œ˜M˜—J˜—š¡œžœ
žœ˜7šžœžœ
žœ˜Mšœžœ˜/Mšœžœ3˜;Mš	œžœžœžœ	žœ˜3Mš
œ6˜6š
žœžœ
žœžœ
žœ˜@M˜M˜———š¡œžœ
žœžœžœžœ˜Qš¡œ˜Mšœžœ˜*šžœ%žœžœ˜4Mš
œ#˜#Mš
œ˜Mšœžœ˜——Mšžœžœ
žœ˜.š
œ˜M˜M˜——š
¡œžœ
žœžœžœ˜9Mš
œ'˜'šžœžœ
žœ˜Mšœžœ˜Mš
œ6˜6Mšžœ˜M˜M˜——š¡
œžœ
žœ
žœžœ
žœžœžœ˜GMš
œ˜Mš
œ˜M˜—š¡œžœ
žœžœ
žœžœžœ˜Kš¡œ˜Mš
œ	˜	—Mšžœžœ
žœ
žœ˜Mš
œ!˜!Mš
œ˜M˜—š¡
œžœ
žœ
žœžœ
žœžœžœ˜OMš
œ%˜%Mš
œ˜M˜M˜—š¡œž
œžœ
žœžœžœ˜Oš¡œ˜Mš
œ	˜	—š¡œ˜Mšœžœ˜*Mš
œ˜Mš
œ˜M˜—Mšžœžœ
žœ
žœ˜M˜šžœ
žœ
ž˜Mšœ$žœ'˜PMšœ&žœ)˜TMšœ$žœ'˜PMšœ!žœ$˜JMšžœ!˜(—Mš
œ˜M˜M˜—š¡œžœ
žœ˜&Mšœžœ˜%Mš
œ7˜7š¡œžœ
˜)Mšœžœ
žœ˜Mšœžœ˜)Mšœžœ&˜?šžœ1žœ˜9Mšœžœ˜+š
žœ
žœ
žœ
žœžœžœ
ž˜NMš	œžœžœ
žœ
žœ˜XMšžœ
˜—Mš
œX˜XMš
œ5˜5Mš
œ'˜'Mšžœ
žœ˜——Mšžœžœ
žœ
˜"Mšžœžœ
žœ
˜%Mš
œ)˜)—š¡
œžœ
žœ	žœ˜@Mšœžœ˜)Mšœžœ˜+š
žœ
žœ
žœ
žœžœžœ
ž˜NMš	œžœžœ
žœ
žœ˜XMšžœ
˜—Mš
œX˜XMš
œ,˜,Mš
œ5˜5Mš
œ3˜3—M™
Mš
¡	œžœ
žœ
žœžœ
˜.Mš¡œžœžœžœ
˜4Mšœžœ!˜0š
¡œžœžœ
žœžœ˜=šžœž˜"Mšœ
žœ
žœ˜0Mšœžœ
žœ˜;Mšžœžœ˜——Mšœ
žœžœ	žœ žœ
žœžœžœžœžœ˜rš¡œžœ
žœžœ
žœžœ˜JMšœžœ
˜Mšœžœ
˜
š¡	œ˜Mš
œ+˜+Mšžœ˜—š¡
œ˜!Mšœžœ#˜1Mš
œ˜Mšžœ˜—Mš
œ'˜'—š¡œžœ
žœžœ
žœžœ˜GMšœžœ
˜Mšœžœ
˜
š¡	œ˜Mš
œ+˜+Mšžœ˜—š¡
œ˜!Mšœžœ#˜1Mš
œ˜Mšžœ˜—Mšžœžœ
žœ
˜ Mš
œ!˜!Mšžœžœ
žœ
˜ Mš
œ&˜&Mšžœžœ
žœ
˜ Mš
œ$˜$Mšžœžœ
žœ
˜ Mš
œ$˜$Mšžœžœ
žœ
˜ Mš
œ˜Mš
œ%˜%Mš
œ˜Mš
œ+˜+—Mšœžœžœ	žœžœ
žœžœžœžœžœ˜_š¡œžœ
žœžœ
žœžœ˜IMšœžœžœ
˜š¡
œ˜!Mšœžœžœ#˜8Mš
œ$˜$Mšžœ˜—Mš
œ!˜!Mšžœžœ
žœ
˜ Mš
œ&˜&Mšžœžœ
žœ
˜ Mš
œ*˜*Mšžœžœ
žœ
˜ Mš
œ$˜$Mšžœžœ
žœ
˜ Mš
œ$˜$Mšžœžœ
žœ
˜ Mšžœžœ
žœ
˜&Mšžœžœ
žœ˜,—š
¡œžœ
žœ	žœžœ˜QMš
œ&˜&Mšžœ	žœ
žœ
žœ
˜Mš
œ˜Mš
œ˜—š¡
œžœ
žœ	žœ˜CMš
œ˜Mš
œ˜—š¡œžœ
žœžœ˜<Mš
œ8˜8—š¡œžœ
žœžœ˜GMš
œ8˜8—š
¡
œžœ
žœžœžœ˜IMš
œ?˜?Mš
œ7˜7—š¡	œžœ
žœ	žœ˜:Mš
œ0˜0Mš
œ2˜2—š¡
œžœ
žœ	žœ	žœ
žœ˜<Mš
œ-˜-—š¡œžœ
žœ	žœ˜@Mš
œ'˜'—š¡œžœ
žœ	žœ˜KMš
œ,˜,Mš
œ(˜(Mš
œ-˜-—š¡œžœ
žœžœ˜FMš
œ0˜0—š¡
œžœ
žœžœ˜CMš
œ˜Mš
œ˜M˜j—š¡
œžœ
žœ	žœ˜CMš
œ/™/Mš
œ˜M˜V—š¡
œžœ
žœ	žœ	žœ
žœ˜?Mšœžœ˜Mš
œ˜Mš
œF˜F—š¡œžœ	žœžœ˜=šžœ
žœž˜Mš
œ(˜(Mš
œK˜KMšžœ˜——š
¡
œžœ	žœ
žœžœ˜>šžœ
žœ
ž˜Mšžœžœ˜3Mšžœžœ˜3Mšžœžœ˜——Mšœ
žœ+˜<š¡œžœ
žœ
žœ˜+Mš
œ˜š
œ	˜	Mš
œH˜H—Mš
œ=˜=—š¡œžœ
žœ˜9M™ìM™¡Mš	œžœ
žœ
žœžœ
˜Mšœ
žœžœ
˜Mšœ	žœ
˜M˜Mš¡
œžœ˜<Mš
œ˜Mš
œA˜Ašžœ
žœ˜šžœžœžœ
 ˜NM˜î
——šžœ !˜(šžœžœ˜ Mšœ#žœ-žœ˜ZMš
œ1˜1Mšœž	œê
˜ƒ—Mšžœ˜ ——š¡œžœ
žœ
žœ
žœ
žœ
žœžœžœžœ˜oMšœžœ
˜š
žœžœ
žœ
žœžœ	žœ
ž˜EMš
œ˜šžœ"žœžœ
žœ˜7Mšœžœ
˜Mšžœ˜—Mšžœ˜——š¡œžœ
žœ	žœ
žœžœžœžœ	žœ
žœžœ˜yMš
œm™mšžœž˜!˜š¡œ˜Mšžœ"žœ$žœ$žœ˜€
—M˜—˜Mšžœžœ›
žœ˜¾
—Mšžœžœ
˜—šžœ	žœ
žœžœ˜)šœžœžœ˜Mšœžœžœ˜C—Mšžœ˜—Mšœ ˜—Mšžœ
˜——…—¡¢ÖÑ