<> <> <> <> DIRECTORY AccessControl USING[AccessFailed, MaxAccessCacheEntries], AccessControlCache USING[SetAccessControlCacheInitialized], AccessControlFile USING[LockConflict, LockFileOrPageRun, LockItem, StartAccessControlFile], AccessControlLight USING[SetAccessControlLightInitialized], AccessControlMain USING[EnumAllDataEntriesInOwnerFile, EnumAllOwners, CreateAndInitOwnerFile, ReadOwnerFileHead, RegisterVolGroup, ReorgOwnerFile, UnRegisterVolGroup], AccessControlPrivate USING[OwnerStringRep], AccessControlTransMap USING[IsAlpineWheel], AccessControlUtility USING[MakeOwnerStringRepFromRName], AlpineEnvironment USING[Conversation, FileID, LockFailure, NeededAccess, OperationFailure, OwnerName, OwnerPropertySet, OwnerPropertyValuePair, PageCount, UniversalFile, UnknownType, VolumeGroupID, VolumeID], AlpineInternal USING[TransHandle], GVNames USING[CheckStamp]; AccessControlHeavyImpl: CEDAR PROGRAM IMPORTS AC: AccessControl, ACC: AccessControlCache, ACF: AccessControlFile, ACL: AccessControlLight, ACM: AccessControlMain, ACU: AccessControlUtility, GV: GVNames, TM: AccessControlTransMap EXPORTS AccessControl, AccessControlPrivate = BEGIN OPEN ACP: AccessControlPrivate, AE: AlpineEnvironment, AI: AlpineInternal; <> CreateAndInitializeOwnerFile: PUBLIC PROCEDURE[conversation: AE.Conversation, transHandle: AI.TransHandle, volGroupID: AE.VolumeGroupID, ownerFileVolID: AE.VolumeID, totalQuota, volumeGroupSize: AE.PageCount, overCommitQuotaDuringInitializeIfNeeded: BOOLEAN, maxNumberOfOwnersAllowed: NAT, nOwnerCacheEntries: NAT] RETURNS[ownerFileID: AE.FileID] = BEGIN <> IF NOT TM.IsAlpineWheel[transHandle, conversation] THEN ERROR AC.AccessFailed[alpineWheel]; RETURN[ACM.CreateAndInitOwnerFile[volGroupID, transHandle, ownerFileVolID, totalQuota, volumeGroupSize, overCommitQuotaDuringInitializeIfNeeded, maxNumberOfOwnersAllowed, nOwnerCacheEntries]]; END; RegisterVolumeGroup: PUBLIC PROCEDURE[conversation: AE.Conversation, transHandle: AI.TransHandle, volGroupID: AE.VolumeGroupID, ownerFileUniversalFile: AE.UniversalFile, nOwnerCacheEntries: NAT] RETURNS[newOwnerFileID: AE.FileID] = TRUSTED BEGIN <> myLockItem: ACF.LockItem; IF NOT TM.IsAlpineWheel[transHandle, conversation] THEN ERROR AC.AccessFailed[alpineWheel]; DO BEGIN newOwnerFileID _ ACM.RegisterVolGroup[volGroupID, transHandle, ownerFileUniversalFile, nOwnerCacheEntries ! ACF.LockConflict => BEGIN myLockItem.mode _ lockItem.mode; WITH l: lockItem SELECT FROM file => myLockItem.whatToLock _ file[l.transID, l.universalFile, l.refPattern]; pageRun => myLockItem.whatToLock _ pageRun[l.openFileID, l.pageRun]; ENDCASE; GOTO lockConflict; END]; RETURN; EXITS lockConflict => ACF.LockFileOrPageRun[myLockItem]; -- may error AC.LockFailed[timeout]. END; ENDLOOP; END; UnRegisterVolumeGroup: PUBLIC PROCEDURE[conversation: AE.Conversation, transHandle: AI.TransHandle, volGroupID: AE.VolumeGroupID] = TRUSTED BEGIN <> myLockItem: ACF.LockItem; IF NOT TM.IsAlpineWheel[transHandle, conversation] THEN ERROR AC.AccessFailed[alpineWheel]; DO BEGIN ACM.UnRegisterVolGroup[volGroupID, transHandle ! ACF.LockConflict => BEGIN myLockItem.mode _ lockItem.mode; WITH l: lockItem SELECT FROM file => myLockItem.whatToLock _ file[l.transID, l.universalFile, l.refPattern]; pageRun => myLockItem.whatToLock _ pageRun[l.openFileID, l.pageRun]; ENDCASE; GOTO lockConflict; END]; RETURN; EXITS lockConflict => ACF.LockFileOrPageRun[myLockItem]; -- may error AC.LockFailed[timeout]. END; ENDLOOP; END; <> ReorganizeOwnerFile: PUBLIC PROCEDURE[conversation: AE.Conversation, transHandle: AI.TransHandle, volGroupID: AE.VolumeGroupID, maxNumberOfOwnersAllowed: NAT] = TRUSTED BEGIN <> myLockItem: ACF.LockItem; IF NOT TM.IsAlpineWheel[transHandle, conversation] THEN ERROR AC.AccessFailed[alpineWheel]; DO BEGIN ACM.ReorgOwnerFile[volGroupID, transHandle, maxNumberOfOwnersAllowed ! ACF.LockConflict => BEGIN myLockItem.mode _ lockItem.mode; WITH l: lockItem SELECT FROM file => myLockItem.whatToLock _ file[l.transID, l.universalFile, l.refPattern]; pageRun => myLockItem.whatToLock _ pageRun[l.openFileID, l.pageRun]; ENDCASE; GOTO lockConflict; END]; RETURN; EXITS lockConflict => ACF.LockFileOrPageRun[myLockItem]; -- may error AC.LockFailed[timeout]. END; ENDLOOP; END; <> EnumerateAllOwners: PUBLIC PROCEDURE[conversation: AE.Conversation, transHandle: AI.TransHandle, volGroupID: AE.VolumeGroupID, prevOwnerName: AE.OwnerName, desiredOwnerProperties: AE.OwnerPropertySet] RETURNS [ownerName: AE.OwnerName, ownerProperties: LIST OF AE.OwnerPropertyValuePair] = TRUSTED BEGIN <> myLockItem: ACF.LockItem; IF NOT TM.IsAlpineWheel[transHandle, conversation] THEN ERROR AC.AccessFailed[alpineWheel]; DO BEGIN [ownerName, ownerProperties] _ ACM.EnumAllOwners[volGroupID, transHandle, prevOwnerName, desiredOwnerProperties ! ACF.LockConflict => BEGIN myLockItem.mode _ lockItem.mode; WITH l: lockItem SELECT FROM file => myLockItem.whatToLock _ file[l.transID, l.universalFile, l.refPattern]; pageRun => myLockItem.whatToLock _ pageRun[l.openFileID, l.pageRun]; ENDCASE; GOTO lockConflict; END]; RETURN; EXITS lockConflict => ACF.LockFileOrPageRun[myLockItem]; -- may error AC.LockFailed[timeout]. END; ENDLOOP; END; <> EnumerateAllDataEntriesInOwnerFile: PUBLIC PROCEDURE[conversation: AE.Conversation, transHandle: AI.TransHandle, volGroupID: AE.VolumeGroupID, contRecNum: INT, desiredOwnerProperties: AE.OwnerPropertySet] RETURNS [entryEmpty, entryValid: BOOLEAN, ownerName: AE.OwnerName, ownerProperties: LIST OF AE.OwnerPropertyValuePair, nextContRecNum: INT] = TRUSTED BEGIN <> myLockItem: ACF.LockItem; IF NOT TM.IsAlpineWheel[transHandle, conversation] THEN ERROR AC.AccessFailed[alpineWheel]; DO BEGIN [entryEmpty, entryValid, ownerName, ownerProperties, nextContRecNum] _ ACM.EnumAllDataEntriesInOwnerFile[volGroupID, transHandle, contRecNum, desiredOwnerProperties ! ACF.LockConflict => BEGIN myLockItem.mode _ lockItem.mode; WITH l: lockItem SELECT FROM file => myLockItem.whatToLock _ file[l.transID, l.universalFile, l.refPattern]; pageRun => myLockItem.whatToLock _ pageRun[l.openFileID, l.pageRun]; ENDCASE; GOTO lockConflict; END]; RETURN; EXITS lockConflict => ACF.LockFileOrPageRun[myLockItem]; -- may error AC.LockFailed[timeout]. END; ENDLOOP; END; <> ReadOwnerFileHeader: PUBLIC PROCEDURE[conversation: AE.Conversation, transHandle: AI.TransHandle, volGroupID: AE.VolumeGroupID] RETURNS [version: NAT, recordedVolGroupID: AE.VolumeGroupID, totalQuota, quotaLeft, volumeGroupSize: AE.PageCount, numberOfOwners, numberOfOwnerSlotsInUse, maxNumberOfOwnersAllowed: NAT] = TRUSTED BEGIN <> myLockItem: ACF.LockItem; IF NOT TM.IsAlpineWheel[transHandle, conversation] THEN ERROR AC.AccessFailed[alpineWheel]; DO BEGIN [version, recordedVolGroupID, totalQuota, quotaLeft, volumeGroupSize, numberOfOwners, numberOfOwnerSlotsInUse, maxNumberOfOwnersAllowed] _ ACM.ReadOwnerFileHead[volGroupID, transHandle, heavy ! ACF.LockConflict => BEGIN myLockItem.mode _ lockItem.mode; WITH l: lockItem SELECT FROM file => myLockItem.whatToLock _ file[l.transID, l.universalFile, l.refPattern]; pageRun => myLockItem.whatToLock _ pageRun[l.openFileID, l.pageRun]; ENDCASE; GOTO lockConflict; END]; RETURN; EXITS lockConflict => ACF.LockFileOrPageRun[myLockItem]; -- may error AC.LockFailed[timeout]. END; ENDLOOP; END; <> ReadOwnerFileProperties: PUBLIC PROCEDURE[conversation: AE.Conversation, transHandle: AI.TransHandle, volGroupID: AE.VolumeGroupID] RETURNS [totalQuota, quotaLeft, volumeGroupSize: AE.PageCount, numberOfOwners, numberOfOwnerSlotsInUse, maxNumberOfOwnersAllowed: NAT] = TRUSTED BEGIN <> myLockItem: ACF.LockItem; IF NOT TM.IsAlpineWheel[transHandle, conversation] THEN ERROR AC.AccessFailed[alpineWheel]; DO BEGIN [, , totalQuota, quotaLeft, volumeGroupSize, numberOfOwners, numberOfOwnerSlotsInUse, maxNumberOfOwnersAllowed] _ ACM.ReadOwnerFileHead[volGroupID, transHandle, light ! ACF.LockConflict => BEGIN myLockItem.mode _ lockItem.mode; WITH l: lockItem SELECT FROM file => myLockItem.whatToLock _ file[l.transID, l.universalFile, l.refPattern]; pageRun => myLockItem.whatToLock _ pageRun[l.openFileID, l.pageRun]; ENDCASE; GOTO lockConflict; END]; RETURN; EXITS lockConflict => ACF.LockFileOrPageRun[myLockItem]; -- may error AC.LockFailed[timeout]. END; ENDLOOP; END; <> AccessControlAlreadyInitialized: ERROR = CODE; AccessCacheSizeOutOfRange: ERROR = CODE; AlpineWheelsNotGroupOrNonExistent: ERROR = CODE; accessControlInitialized: BOOLEAN _ FALSE; InitVolatileData: PUBLIC PROCEDURE[nAccessCacheEntries: NAT, alpineWheels: AlpineEnvironment.OwnerName] = BEGIN -- non system-fatal errors: none. IF nAccessCacheEntries NOT IN [1..AC.MaxAccessCacheEntries] THEN ERROR AccessCacheSizeOutOfRange; TRUSTED BEGIN -- check that name is not bad length. tempOwnerStringRep: ACP.OwnerStringRep; ACU.MakeOwnerStringRepFromRName[alpineWheels, @tempOwnerStringRep]; END; SELECT GV.CheckStamp[name: alpineWheels, oldStamp: ] FROM group => NULL; individual, notFound => ERROR AlpineWheelsNotGroupOrNonExistent; ENDCASE => NULL; -- well, we tried. Let the system come up anyway. ACF.StartAccessControlFile[]; -- be sure exported variables are defined. ACC.SetAccessControlCacheInitialized[nAccessCacheEntries]; ACL.SetAccessControlLightInitialized[alpineWheels]; accessControlInitialized _ TRUE; END; <> InternalAccessControlLogicError: PUBLIC ERROR = CODE; SpecialOwnerForAlpineAdmin: PUBLIC AE.OwnerName _ "SpecialOwnerForAlpineAdmin"; <> AccessFailed: PUBLIC --CALLING-- ERROR[why: AE.NeededAccess] = CODE; LockFailed: PUBLIC ERROR[why: AE.LockFailure] = CODE; OperationFailed: PUBLIC --CALLING-- ERROR[why: AE.OperationFailure] = CODE; StaticallyInvalid: PUBLIC --CALLING-- ERROR = CODE; Unknown: PUBLIC --CALLING-- ERROR[why: AE.UnknownType] = CODE; END. Edit Log Initial: Kolling: 18-Nov-81 12:17:05: infrequent operations on volume groups. <> <> <<>>