Filing: PROGRAM 10 VERSION 5 = BEGIN
DEPENDS UPON
BulkData(0) VERSION 1,
CHName (2) VERSION 0,
Authentication(14) VERSION 2, -- was VERSION 1
Time(15) VERSION 2,
FilingAttributes (10) VERSION 5;
Time: TYPE = Time.Time; -- seconds
nullTime: Time = Time.earliestTime;

EmptyRecord: TYPE = RECORD [ ];
AttributeType: TYPE = FilingAttributes.AttributeType;
AccessSequence: TYPE = FilingAttributes.AccessSequence;
Attribute: TYPE = FilingAttributes.Attribute;
AttributeSequence: TYPE = FilingAttributes.AttributeSequence;
Interpretation: TYPE = FilingAttributes.Interpretation;
AttributeTypeSequence: TYPE = SEQUENCE OF AttributeType;
allAttributeTypes: AttributeTypeSequence = [37777777777B];
ControlType: TYPE = { lock(0), timeout(1), access(2) };
ControlTypeSequence: TYPE = SEQUENCE 3 OF ControlType;
Control: TYPE = CHOICE ControlType OF {
lock =>	Lock,		-- (0)
timeout =>	Timeout,		-- (1)
access =>	AccessSequence	-- (2)
};
ControlSequence: TYPE = SEQUENCE 3 OF Control;

Lock: TYPE = { lockNone(0), share(1), exclusive(2) };

Timeout: TYPE = CARDINAL; -- in seconds
defaultTimeout: Timeout = 177777B;	-- actual value impl.-dependent

ScopeType: TYPE = { count(0), direction(1), filter(2), depth(3) };
Scope: TYPE = CHOICE ScopeType OF {
count =>	Count,	-- (0)
depth =>	Depth,	-- (3)
direction =>	Direction,	-- (1)
filter =>	Filter	-- (2)
};
ScopeSequence: TYPE = SEQUENCE 4 OF Scope;

Count: TYPE = CARDINAL;
unlimitedCount: Count = 177777B;

Depth: TYPE = CARDINAL;
allDescendants: Depth = 177777B;

Direction: TYPE = { forward(0), backward(1) };

FilterType: TYPE = {
less(0), lessOrEqual(1), equal(2), notEqual(3), greaterOrEqual(4), greater(5), 
and(6), or(7), not(8),
none(9), all(10),
matches(11)
};

RelationFilter: TYPE = RECORD [attribute: Attribute, interpretation: Interpretation];
LogicFilter: TYPE = SEQUENCE OF Filter;
PatternFilter: TYPE = RECORD [attribute: Attribute];

Filter: TYPE = CHOICE FilterType OF {
less, lessOrEqual, equal, notEqual, greaterOrEqual, greater => RelationFilter,
and, or =>	EmptyRecord, -- LogicFilter, Cyclic Dependency feature of Sirocco!
not =>	EmptyRecord, -- Filter, Cyclic Dependency feature of Sirocco!
none, all =>	EmptyRecord,
matches =>	PatternFilter
};


nullFilter: Filter = all [];
Credentials: TYPE = Authentication.Credentials;

PrimaryCredentials: TYPE = Authentication.Credentials;

Strength: TYPE = { none(0), simple(1), strong(2) };
SecondaryCredentials: TYPE = CHOICE Strength OF {
none =>	EmptyRecord,	-- (0)
simple =>	Secondary,		-- (1)
strong =>	EncryptedSecondary	-- (2)
};

SecondaryItemType: TYPE = LONG CARDINAL;
SecondaryType: TYPE = SEQUENCE 10 OF SecondaryItemType;

SecondaryValueType: TYPE = SEQUENCE OF UNSPECIFIED;
Secondary: TYPE = SEQUENCE 10 OF SecondaryItem;
SecondaryItem: TYPE = RECORD [
type: SecondaryItemType,
value: SecondaryValueType
];

EncryptedSecondary: TYPE = SEQUENCE OF Authentication.Block;

Handle: TYPE = ARRAY 2 OF UNSPECIFIED;
nullHandle: Handle = [0, 0];

SessionToken: TYPE = ARRAY 2 OF UNSPECIFIED;
Session: TYPE = RECORD [token: SessionToken, verifier: Verifier];
Verifier: TYPE = Authentication.Verifier;
ByteAddress: TYPE = LONG CARDINAL;
ByteCount: TYPE = LONG CARDINAL;
endOfFile: LONG CARDINAL = 37777777777B;	-- logical end of file

ByteRange: TYPE = RECORD [firstByte: ByteAddress, count: ByteCount];
Logon: PROCEDURE [ service: CHName.Name, credentials: Credentials, verifier: Verifier ] 
RETURNS [ session: Session ]
REPORTS [ AuthenticationError, ServiceError, SessionError, UndefinedError ] = 0;

Logoff: PROCEDURE [ session: Session ]
REPORTS [ AuthenticationError, ServiceError, SessionError, UndefinedError ] = 1;

Continue: PROCEDURE [ session: Session ]
RETURNS [ continuance: CARDINAL ]
REPORTS [ AuthenticationError, SessionError, UndefinedError ] = 19;

SetService: PROCEDURE [ service: CHName.Name, session: Session ]
REPORTS [ AuthenticationError, ServiceError, SessionError, UndefinedError ] = 21;
Open: PROCEDURE [ attributes: AttributeSequence, directory: Handle,
controls: ControlSequence, session: Session ]
RETURNS [ file: Handle ]
REPORTS [ AccessError, AttributeTypeError, AttributeValueError,
AuthenticationError, ControlTypeError, ControlValueError,
HandleError, SessionError, UndefinedError ] = 2;

Close: PROCEDURE [ file: Handle, session: Session ]
REPORTS [ AuthenticationError, HandleError, SessionError, UndefinedError ]  = 3;
Create: PROCEDURE [ directory: Handle, attributes: AttributeSequence,
controls: ControlSequence, session: Session ]
RETURNS [ file: Handle ]
REPORTS [ AccessError, AttributeTypeError, AttributeValueError,
AuthenticationError, ControlTypeError, ControlValueError,
HandleError, InsertionError, SessionError, SpaceError, UndefinedError ] = 4;

Delete: PROCEDURE [ file: Handle, session: Session ]
REPORTS [ AccessError, AuthenticationError, HandleError, SessionError,
UndefinedError ] = 5;
GetControls: PROCEDURE [ file: Handle, types: ControlTypeSequence, session: Session ]
RETURNS [ controls: ControlSequence ]
REPORTS [AccessError, AttributeTypeError, AuthenticationError, ControlTypeError, HandleError, SessionError, UndefinedError ] = 6;

ChangeControls: PROCEDURE [ file: Handle, controls: ControlSequence, session: Session ]
REPORTS [AccessError, AttributeTypeError, AuthenticationError, ControlTypeError, ControlValueError, HandleError, SessionError, UndefinedError ] = 7;
GetAttributes: PROCEDURE [ file: Handle, types: AttributeTypeSequence, session: Session ]
RETURNS [ attributes: AttributeSequence ]
REPORTS [AccessError, AttributeTypeError, AuthenticationError, HandleError, SessionError, UndefinedError ] = 8;

ChangeAttributes: PROCEDURE [file: Handle, attributes: AttributeSequence,
session: Session ]
REPORTS [AccessError, AttributeTypeError, AuthenticationError, HandleError, SessionError, SpaceError, UndefinedError ] = 9;

UnifyAccessLists: PROCEDURE [directory: Handle, session: Session ]
REPORTS [AccessError, AuthenticationError, HandleError, SessionError, UndefinedError ]  = 20;
Copy: PROCEDURE [ file, destinationDirectory: Handle, attributes: AttributeSequence, controls: ControlSequence, session: Session ]
RETURNS [ newFile: Handle ]
REPORTS [AccessError, AttributeTypeError, AttributeValueError, AuthenticationError, ControlTypeError, ControlValueError, HandleError, InsertionError, SessionError, SpaceError, UndefinedError ] = 10;

Move: PROCEDURE [ file, destinationDirectory: Handle, attributes: AttributeSequence, session: Session ]
REPORTS [AccessError, AttributeTypeError, AttributeValueError, AuthenticationError, HandleError, InsertionError, SessionError, SpaceError, UndefinedError ] = 11;
Store: PROCEDURE [ directory: Handle, attributes: AttributeSequence,
controls: ControlSequence, content: BulkData.Source, session: Session ]
RETURNS [ file: Handle ]
REPORTS [AccessError, AttributeTypeError, AttributeValueError,
AuthenticationError, ConnectionError, ControlTypeError,
ControlValueError, HandleError, InsertionError, SessionError,
SpaceError, TransferError, UndefinedError ] = 12;

Retrieve: PROCEDURE [ file: Handle, content: BulkData.Sink, session: Session ]
REPORTS [AccessError, AuthenticationError, ConnectionError, HandleError, SessionError, SpaceError, TransferError, UndefinedError ] = 13;

Replace: PROCEDURE [ file: Handle,  attributes: AttributeSequence,
content: BulkData.Source, session: Session ]
REPORTS [AccessError, AttributeTypeError, AttributeValueError,
AuthenticationError, ConnectionError, HandleError, SessionError,
SpaceError, TransferError, UndefinedError ] = 14;
Serialize: PROCEDURE [ file: Handle, serializedFile: BulkData.Sink, session: Session ]
REPORTS [AccessError, AuthenticationError, ConnectionError, HandleError, SessionError, TransferError, UndefinedError ] = 15;

Deserialize: PROCEDURE [ directory: Handle, attributes: AttributeSequence,
controls: ControlSequence, serializedFile: BulkData.Source, session: Session ]
RETURNS [ file: Handle ]
REPORTS [AccessError, AttributeTypeError, AttributeValueError,
AuthenticationError, ConnectionError, ControlTypeError,
ControlValueError, HandleError, InsertionError, SessionError,
SpaceError, TransferError, UndefinedError ] = 16;
RetrieveBytes: PROCEDURE [ file: Handle, range: ByteRange, sink: BulkData.Sink,
session: Session ]
REPORTS [AccessError, HandleError, RangeError, SessionError, UndefinedError ] = 22;

ReplaceBytes: PROCEDURE [ file: Handle, range: ByteRange, source: BulkData.Source, session: Session ]
REPORTS [AccessError, HandleError, RangeError, SessionError, SpaceError,
UndefinedError ] = 23;
Find: PROCEDURE [ directory: Handle, scope: ScopeSequence, controls: ControlSequence, session: Session ]
RETURNS [ file: Handle ]
REPORTS [ AccessError, AuthenticationError, ConnectionError, ControlTypeError, ControlValueError, HandleError, ScopeTypeError, ScopeValueError, SessionError, UndefinedError ] = 17;

List: PROCEDURE [ directory: Handle, types: AttributeTypeSequence, scope: ScopeSequence, listing: BulkData.Sink, session: Session ]
REPORTS [ AccessError, AttributeTypeError, AuthenticationError, ConnectionError, HandleError, ScopeTypeError, ScopeValueError, SessionError, TransferError, UndefinedError ] = 18;
AttributeTypeError: ERROR [ problem: ArgumentProblem, type: AttributeType] = 0;
AttributeValueError: ERROR [ problem: ArgumentProblem, type: AttributeType] = 1;

ControlTypeError: ERROR [ problem: ArgumentProblem, type: ControlType] = 2;
ControlValueError: ERROR [ problem: ArgumentProblem, type: ControlType] = 3;

ScopeTypeError: ERROR [ problem: ArgumentProblem, type: ScopeType] = 4;
ScopeValueError: ERROR [ problem: ArgumentProblem, type: ScopeType] = 5;
ArgumentProblem: TYPE = { illegal(0), disallowed(1), unreasonable(2),
unimplemented(3), duplicated(4), missing(5) };

AccessError: ERROR [problem: AccessProblem] = 6;
AccessProblem: TYPE = { accessRightsInsufficient(0), accessRightsIndeterminate(1),
fileChanged(2), fileDamaged(3), fileInUse(4), fileNotFound(5), fileOpen(6) };

AuthenticationError: ERROR [problem: Authentication.Problem] = 7;

ConnectionError: ERROR [problem: ConnectionProblem] = 8;
ConnectionProblem: TYPE = {
noRoute(0), noResponse(1), transmissionHardware(2), transportTimeout(3),
tooManyLocalConnections(4), tooManyRemoteConnections(5),
missingCourier(6), missingProgram(7), missingProcedure(8), protocolMismatch(9),
parameterInconsistency(10), invalidMessage(11), returnTimedOut(12),
otherCallProblem(177777B)
};

HandleError: ERROR [problem: HandleProblem] = 9;
HandleProblem: TYPE = { invalid(0), nullDisallowed(1), directoryRequired(2) };

InsertionError: ERROR [problem: InsertionProblem] = 10;
InsertionProblem: TYPE = { positionUnavailable(0), fileNotUnique(1), loopInHierarchy(2) };

RangeError: ERROR [problem: ArgumentProblem] = 16;

ServiceError: ERROR [problem: ServiceProblem] = 11;
ServiceProblem: TYPE = { cannotAuthenticate(0), serviceFull(1),
serviceUnavailable(2), sessionInUse(3), serviceUnknown(4) };

SessionError: ERROR [problem: SessionProblem ] = 12;
SessionProblem: TYPE = { tokenInvalid(0), serviceAlreadySet(1) };

SpaceError: ERROR [problem: SpaceProblem ] = 13;
SpaceProblem: TYPE = { allocationExceeded(0), attributeAreaFull(1), mediumFull(2) };

TransferError: ERROR [problem: TransferProblem ] = 14;
TransferProblem: TYPE = { aborted(0), checksumIncorrect(1),
formatIncorrect(2), noRendevous(3), wrongDirection(4) };

UndefinedError: ERROR [problem: UndefinedProblem ] = 15;
UndefinedProblem: TYPE = CARDINAL;

END.

^Filing5.cr
Copyright Σ 1986, 1987, 1988 by Xerox Corporation.  All rights reserved.
Bill Jackson (bj) April 20, 1987 11:46:50 pm PDT
Tim Diebert: June 6, 1988 7:36:45 am PDT

Common Definitions
(extracted into FilingAttributes Program)
Attributes
AttributeType: TYPE = LONG CARDINAL;
Attribute: TYPE = RECORD [type: AttributeType, value: AttributeValue];
AttributeSequence: TYPE = SEQUENCE OF Attribute;
Controls
AccessType: TYPE = {
read(0), write(1), owner(2), -- all files
add(3), remove(4), -- directories only
fullAccess(177777B) };
AccessSequence: TYPE = SEQUENCE 5 OF AccessType;
Scopes
relations
logical
constants
patterns
interpretation ignored if attribute interpreted by implementor
Interpretation: TYPE = { interpretationNone(0), boolean(1), cardinal(2),
longCardinal(3), time(4), integer(5), longInteger(6), string(7) };
Handles and Authentication
Credentials: TYPE = RECORD [
primary: PrimaryCredentials,
secondary: SecondaryCredentials
];
nullPrimaryCredentials: TYPE = Authentication.nullCredentials; -- bug?
Random Access
Remote procedures
Logging On and Off
Opening and Closing Files
Creating and Deleting Files
Getting and Changing Controls (transient)
Getting and Changing Attributes (permanent)
Copying and Moving Files
Transfering Bulk Data (File Content)
Transferring Bulk Data (Serialized Files)
Random Access to File Data
Locating and Listing Files in a Directory
Remote Errors

AuthenticationError: ERROR [problem: AuthenticationProblem, type: SecondaryType] = 7;
AuthenticationProblem: TYPE = {
primaryCredentialInvalid(0),
verifierInvalid(1),
verifierExpired(2),
verifierRefused(3),
primaryCredentialsExpired(4),
inappropriatePrimaryCredentials(5),
secondaryCredentialsRequired(6),
secondaryCredentialsTypeInvalid(7),
secondaryCredentialsValueInvalid(8)
};
communication problems
resource problems
remote program implementation problems
miscellaneous
Κ
k˜
codeš
œ
™
Kš
œH™HK™0K™(—K™šΟnœΟkœžœž˜$šžœ
ž˜Kšœžœ˜Jšœžœ˜KšœžœΟc˜.Kšœ	žœ˜Jšœžœ˜ —
headš
Οz™KšœžœŸ
˜"K˜#K˜Kšœ
žœžœ˜—š
 )™)Kšœžœ"˜5Kšœžœ#˜7Kšœžœ˜-Kšœžœ&˜=Kšœžœ#˜7—š
 
™
Kšœžœžœ
žœ
™$Kšœžœžœ
žœ˜8K˜:Kšœžœžœ.™FKšœžœžœ
žœ™0—š
 ™Kšœ
žœ&˜7Kšœžœžœžœ
˜6šœ	žœžœ
žœ˜'K˜K˜K˜K˜—Kšœžœžœžœ	˜.K˜Kšœžœ+˜5K˜Kšœ	žœžœŸ
˜'Kšœ#Ÿ˜BK˜Kšœžœ"ŸœŸœ™|Kšœžœžœžœ™0—š
 ™Kšœžœ3˜Bšœžœžœžœ˜#K˜K˜K˜K˜K˜—Kšœžœžœžœ˜*K˜Kšœžœžœ
˜K˜ K˜Kšœžœžœ
˜K˜ K˜Kšœžœ˜.K˜šœžœ˜š
œ	™	K˜O—š
œ™K˜—š
œ	™	K˜—š
œ™K˜—K˜—K˜Kšœžœžœ8˜UKšœ
žœžœ
žœ˜'Kšœžœžœ˜4K˜šœžœžœžœ˜%š
œN˜NKš
œ>™>—KšœŸΠbc%˜MKšœŸ‘%˜DKš
œ˜Kš
œ˜Kš
œ˜K˜—Kšœžœw™‹
K˜K˜—š
 ™Kšœ
žœ˜/š 
Πkz ’ ™Kš
 ™Kš
 ™Kš
 ™—K˜Kšœžœ˜6Kšœžœ&Οb™FK˜Kšœ
žœ%˜3šœžœžœ
žœ˜1KšœŸ˜KšœŸ˜KšœŸ˜#K˜—K˜Kšœžœžœ
žœ
˜(Kšœžœžœžœ˜7K˜Kš	œžœžœ
žœ
žœ
˜3Kšœžœžœžœ˜/šœžœžœ˜Kš
œ˜Kš
œ˜Kš
œ˜—K˜Kšœžœžœ
žœ˜<K˜Kš	œžœžœžœ
žœ
˜&K˜K˜Kš	œžœžœžœ
žœ
˜,Kšœ	žœžœ+˜AKšœ
žœ˜)—š
 
™
Kšœ
žœžœ
žœ
˜"Kšœžœžœ
žœ
˜ Kšœžœ
žœŸ˜?K˜Kšœžœžœ,˜D—š
œ™š
œ™šœž	œH˜XKšžœ˜KšžœI˜PK˜—šœž	œ˜&KšžœI˜PK˜—šœž	œ˜(Kšžœžœ˜!Kšžœ<˜CK˜—šΠnz
 ’	 +˜@Kš’ J˜Q——š
œ™šœž	œb˜qKšžœ˜Kšžœ£
˜ͺ
K˜—šœž	œ#˜3KšžœI˜P——š
œ™šœž	œb˜sKšžœ˜KšžœΏ
˜Ζ
K˜—šœž	œ#˜4KšžœU˜\——š
œ)™)šœž	œ?˜UKšžœ˜%Kšžœz˜
K˜—šœž	œ>˜WKšžœ
˜”
——š
œ+™+š
œž	œA˜YKšžœ"˜)Kšžœh˜oK˜—šœž	œA˜\Kšžœt˜{K˜—šœž	œ'˜BKšžœV˜]——š
œ™šœž	œs˜‚
Kšžœ˜KšžœΏ
˜Ζ
K˜—šœž	œX˜gKšžœš
˜‘
——š
œ$™$šœž	œ|˜Œ
Kšžœ˜Kšžœί
˜ζ
K˜—šœž	œ;˜NKšžœ
˜ˆ
K˜—šœž	œ]˜oKšžœͺ
˜±
——™)š€	 ’	 B˜VKš’ u˜|K˜—š€ ’	 ƒ
˜™
Kš’ ˜Kš’ ί
˜ζ
——š
 ™š€
 ’	 J˜bKš’ L˜SK˜—š€ ’	 N˜eKš’ X˜_——š
œ)™)šœž	œY˜hKšžœ˜Kšžœ­
˜΄
K˜—šœž	œt˜ƒ
Kšžœ«
˜²
———š
œ
™
K™Kšœžœ6˜OKšœžœ6˜PK˜Kšœžœ4˜KKšœžœ4˜LK˜Kšœžœ2˜GKšœžœ2˜HKšœžœ_˜tK˜Kšœžœ˜0Kšœžœ
˜ 
K˜Kšœžœ'˜AKš€ ’ ;™Uš ’ ™Kš
 ™Kš
 ™Kš
 ™Kš
 ™Kš
 ™Kš
 #™#Kš
  ™ Kš
 #™#Kš
 #™#Kš
 ™—K˜Kšœžœ"˜8šœžœ˜š
œ™K˜H—š
œ™K˜8—š
œ&™&K˜OK˜C—š
œ
™
K˜—K˜—K˜Kšœžœ˜0Kšœžœ;˜NK˜Kšœžœ"˜7KšœžœD˜ZK˜Kš
œžœ!˜2K˜Kšœžœ ˜3Kšœžœh˜|K˜Kšœžœ!˜4Kšœžœ-˜AK˜Kš
œžœ˜0KšœžœB˜TK˜Kš
œžœ"˜6Kšœžœ_˜tK˜Kšœžœ#˜8Kšœžœžœ
˜"—K˜Kšžœ
˜—K˜—…—,–>_