DataMuseum.dk

Presents historical artifacts from the history of:

DKUUG/EUUG Conference tapes

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about DKUUG/EUUG Conference tapes

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - metrics - download
Index: T d

⟦e58aeea77⟧ TextFile

    Length: 21592 (0x5458)
    Types: TextFile
    Names: »das-prn.py«

Derivation

└─⟦3d0c2be1b⟧ Bits:30001254 ISODE-5.0 Tape
    └─⟦eba4602b1⟧ »./isode-5.0.tar.Z« 
        └─⟦d3ac74d73⟧ 
            └─⟦this⟧ »isode-5.0/dsap/x500as/das-prn.py« 

TextFile

-- das-prn.py - manually augmented DirectoryAbstractService module

-- $Header: /f/osi/dsap/x500as/RCS/das-prn.py,v 6.0 89/03/18 23:29:25 mrose Rel $
--
--
-- $Log:	das-prn.py,v $
-- Revision 6.0  89/03/18  23:29:25  mrose
-- Release 5.0
-- 

--
--				  NOTICE
--
--    Acquisition, use, and distribution of this module and related
--    materials are subject to the restrictions of a license agreement.
--    Consult the Preface in the User's Manual for the full terms of
--    this agreement.
--
--


DAS
	{
	joint-iso-ccitt
	ds(5)
	modules(1)
	directoryAbstractService(2)
	}

DEFINITIONS ::=

PREFIXES encode decode print

BEGIN

-- EXPORTS
-- 	DirectoryBindArgument ,
-- 	ReadArgument ,
-- 	ReadResult ,
-- 	AbandonArgument ,
-- 	AbandonResult ,
-- 	CompareArgument ,
-- 	CompareResult ,
-- 	ListArgument ,
-- 	ListResult ,
-- 	SearchArgument ,
-- 	SearchResult ,
-- 	AddEntryArgument ,
-- 	AddEntryResult ,
-- 	RemoveEntryArgument ,
-- 	RemoveEntryResult ,
-- 	ModifyEntryArgument ,
-- 	ModifyEntryResult ,
-- 	ModifyRDNArgument ,
-- 	ModifyRDNResult ,
-- 	AbandonedParm ,
-- 	AbandonFailedParm ,
-- 	AttributeErrorParm ,
-- 	NameErrorParm ,
-- 	ReferralParm ,
-- 	SecurityErrorParm ,
-- 	ServiceErrorParm ,
-- 	UpdateErrorParm;

IMPORTS
	Attribute ,
	AttributeType ,
	AttributeValue ,
	AttributeValueAssertion ,
	DistinguishedName ,
	Name ,
	RelativeDistinguishedName
		FROM IF
			{
			joint-iso-ccitt
			ds(5)
			modules(1)
			informationFramework(1)
			}

	OperationProgress ,
	ContinuationReference ,
	InvokeID
		FROM DO
			{
			joint-iso-ccitt
			ds(5)
			modules(1)
			distributedOperations(3)
			}

	Certificate ,
	CertificationPath ,
	AlgorithmIdentifier
		FROM AF
			{
			joint-iso-ccitt
			ds(5)
			modules(1)
			authenticationFramework(7)
			};

PRINTER print

SimpleCredentials
        ::=
        SEQUENCE
        {
        name
                [0] DistinguishedName ,
        validity
                [1] SET
                {
                time1
                        [0] UTCTime OPTIONAL ,
                time2
                        [1] UTCTime OPTIONAL ,
                random1
                        [2] BIT STRING OPTIONAL ,
                random2
                        [3] BIT STRING OPTIONAL
                } OPTIONAL ,
        password
                [2] OCTET STRING
                    OPTIONAL
        }

TokenToSign
	::=
	SEQUENCE
	{
	algorithm
		[0] AlgorithmIdentifier ,
	name
		[1] DistinguishedName ,
	time
		[2] UTCTime ,
	random
		[3] BIT STRING
	}

Token
	::=
	SEQUENCE
	{
		TokenToSign ,
		AlgorithmIdentifier ,
		BIT STRING
	}

StrongCredentials
	::=
	SET
	{
	certificationPath
		[0] CertificationPath
		    OPTIONAL ,
	bindToken
		[1] Token
	}

Credentials
        ::=
        CHOICE
        {
        simple
                [0] SimpleCredentials ,
	strong
	        [1] StrongCredentials ,
	externalProcedure
		[2] EXTERNAL
        }

Versions
        ::=
        BIT STRING
        {
        v1988(0)
        }

SecurityProblem
        ::=
        INTEGER
        {
        inappropriateAuthentication(1) ,
        invalidCredentials(2) ,
        insufficientAccessRights(3) ,
        invalidSignature(4) ,
        protectionRequired(5) ,
	noInformation(6)
        }

ServiceProblem
        ::=
        INTEGER
        {
        busy(1) ,
        unavailable(2) ,
        unwillingToPerform(3) ,
        chainingRequired(4) ,
        unableToProceed(5) ,
        invalidReference(6) ,
        timeLimitExceeded(7) ,
	administrativeLimitExceeded(8) ,
        loopDetected(9) ,
	unavailableCriticalExtension(10) ,
	outOfScope(11) ,
	ditError(12)
        }

EntryInformationSelection
        ::=
        SET
        {
        attributeTypes
                CHOICE
                {
                allAttributes
                        [0] NULL ,
                select
                        [1] SET OF
                                AttributeType
                }
                    -- DEFAULT allAttributes NULL ,
                    OPTIONAL ,
        infoTypes
                [2] INTEGER
                {
                attributeTypesOnly(0) ,
                attributeTypesAndValues(1)
                }
                    -- DEFAULT attributeTypesAndValues
                    OPTIONAL
        }

ServiceControls
        ::=
        SET
        {
        options
                [0] BIT STRING
                {
                preferChaining(0) ,
                chainingProhibited(1) ,
                localScope(2) ,
                dontUseCopy(3) ,
                dontDereferenceAliases(4)
                }
                    -- DEFAULT {} ,
                    OPTIONAL ,
        priority
                [1] INTEGER
                {
                low(0) ,
                medium(1) ,
                high(2)
                }
                    -- DEFAULT medium ,
                    OPTIONAL ,
        timeLimit
                [2] INTEGER
                    OPTIONAL ,
        sizeLimit
                [3] INTEGER
                    OPTIONAL ,
        scopeOfReferral
                [4] INTEGER
                {
                dmd(0) ,
                country(1)
                }
                    OPTIONAL
        }

ProtectionRequest
	::=
	INTEGER
	{
	none (0) ,
	signed (1)
	}

SecurityParameters
	::=
	SET
	{
	certificationPath
		[0] CertificationPath
		    OPTIONAL ,
	name
		[1] DistinguishedName
		    OPTIONAL ,
	time
		[2] UTCTime
		    OPTIONAL ,
	random
		[3] BIT STRING
		    OPTIONAL ,
	target
		[4] ProtectionRequest
		    OPTIONAL
	}

Extension
	::=
	SET
	{
	identifier
		[0] INTEGER ,
	critical
		[1] BOOLEAN
		    -- DEFAULT FALSE ,
		    OPTIONAL ,
	item
		[2] ANY DEFINED BY identifier
	}

EntryInformation
        ::=
        SEQUENCE
        {
                DistinguishedName ,
        fromEntry
                BOOLEAN
                    -- DEFAULT TRUE ,
                    OPTIONAL ,
                SET OF
                        CHOICE
                        {
                                AttributeType ,
                                Attribute
                        }
                    OPTIONAL
        }

LimitProblem
        ::=
        INTEGER
        {
        timeLimitExceeded(0) ,
        sizeLimitExceeded(1) ,
        administrativeLimitExceeded(2)
        }

PartialOutcomeQualifier
        ::=
        SET
        {
        limitProblem
                [0] LimitProblem
                    OPTIONAL ,
        unexplored
                [1] SET OF
                        ContinuationReference
                            OPTIONAL ,
	unavailableCriticalExtensions
		[2] BOOLEAN
		    -- DEFAULT FALSE
		    OPTIONAL
        }

FilterItem
        ::=
        CHOICE
        {
        equality
                [0] AttributeValueAssertion ,
        substrings
                [1] SEQUENCE
                {
                type
                        AttributeType ,
                strings
                        SEQUENCE OF
                                CHOICE
                                {
                                initial
                                        [0] AttributeValue ,
                                any
                                        [1] AttributeValue ,
                                final
                                        [2] AttributeValue
                                }
                } ,
        greaterOrEqual
                [2] AttributeValueAssertion ,
        lessOrEqual
                [3] AttributeValueAssertion ,
        present
                [4] AttributeType ,
        approximateMatch
                [5] AttributeValueAssertion
        }

Filter
        ::=
        CHOICE
        {
        item
                [0] FilterItem ,
        and
                [1] SET OF
                        Filter ,
        or
                [2] SET OF
                        Filter ,
        not
                [3] Filter
        }

EntryModification
        ::=
        CHOICE
        {
        addAttribute
                [0] Attribute ,
        removeAttribute
                [1] AttributeType ,
        addValues
                [2] Attribute ,
        removeValues
                [3] Attribute
        }

AbandonProblem
        ::=
        INTEGER
        {
        noSuchOperation(1) ,
        tooLate(2) ,
        cannotAbandon(3)
        }

AttributeProblem
        ::=
        INTEGER
        {
        noSuchAttributeOrValue(1) ,
        invalidAttributeSyntax(2) ,
        undefinedAttributeType(3) ,
        inappropriateMatching(4) ,
        constraintViolation(5) ,
        attributeOrValueAlreadyExists(6)
        }

NameProblem
        ::=
        INTEGER
        {
        noSuchObject(1) ,
        aliasProblem(2) ,
        invalidAttributeSyntax(3) ,
        aliasDereferencingProblem(4)
        }

UpdateProblem
        ::=
        INTEGER
        {
        namingViolation(1) ,
        objectClassViolation(2) ,
        notAllowedOnLeaf(3) ,
        notAllowedOnRDN(4) ,
        entryAlreadyExists(5) ,
        affectsMultipleDSAs(6) ,
        objectClassModificationProhibited(7)
        }

DirectoryBindArgument
        ::=
        SET
        {
        credentials
                [0] Credentials
                    OPTIONAL ,
        versions
                [1] Versions
                    -- DEFAULT v1988
                    OPTIONAL
        }

DirectoryBindResult
        ::=
        DirectoryBindArgument

ReadArgumentData
        ::=
        SET
        {
        object
                [0] Name ,
        selection
                [1] EntryInformationSelection
                    -- DEFAULT {} ,
                    OPTIONAL ,
                [30] ServiceControls
                    -- DEFAULT {} ,
                    OPTIONAL ,
		[29] SecurityParameters
		    -- DEFAULT {} ,
		    OPTIONAL ,
        requestor
                [28] DistinguishedName
                    OPTIONAL ,
                [27] OperationProgress
		    OPTIONAL ,
	aliasedRDNs
		[26] INTEGER
		    OPTIONAL ,
	extensions
		[25] SET OF
			Extension
		    OPTIONAL
        }

ReadArgument
	::=
	CHOICE
	{
		ReadArgumentData ,
		SEQUENCE
		{
			ReadArgumentData ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}

ReadResultData
        ::=
        SET
        {
        entry
                [0] EntryInformation ,
		[30] SecurityParameters
		    OPTIONAL ,
        performer
                [29] DistinguishedName
                    OPTIONAL ,
        aliasDereferenced
                [28] BOOLEAN
                    -- DEFAULT FALSE
                    OPTIONAL
        }

ReadResult
	::=
	CHOICE
	{
		ReadResultData ,
		SEQUENCE
		{
			ReadResultData ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}

CompareArgumentData
        ::=
        SET
        {
        object
                [0] Name ,
        purported
                [1] AttributeValueAssertion ,
                [30] ServiceControls
                    -- DEFAULT {} ,
                    OPTIONAL ,
		[29] SecurityParameters
		    -- DEFAULT {} ,
		    OPTIONAL ,
        requestor
                [28] DistinguishedName
                    OPTIONAL ,
                [27] OperationProgress
		    OPTIONAL ,
	aliasedRDNs
		[26] INTEGER
		    OPTIONAL ,
	extensions
		[25] SET OF
			Extension
		    OPTIONAL
        }

CompareArgument
	::=
	CHOICE
	{
		CompareArgumentData ,
		SEQUENCE
		{
			CompareArgumentData ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}

CompareResultData
        ::=
        SET
        {
                DistinguishedName
                    OPTIONAL ,
        matched
                [0] BOOLEAN ,
        fromEntry
                [1] BOOLEAN
                    -- DEFAULT TRUE ,
                    OPTIONAL ,
		[30] SecurityParameters
		    OPTIONAL ,
        performer
                [29] DistinguishedName
                    OPTIONAL ,
        aliasDereferenced
                [28] BOOLEAN
                    -- DEFAULT FALSE
                    OPTIONAL
        }

CompareResult
	::=
	CHOICE
	{
		CompareResultData ,
		SEQUENCE
		{
			CompareResultData ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}

AbandonArgument
        ::=
        SEQUENCE
        {
        invokeID
                [0] InvokeID
        }

AbandonResult ::= NULL

ListArgumentData
        ::=
        SET
        {
        object
                [0] Name ,
                [30] ServiceControls
                    -- DEFAULT {} ,
                    OPTIONAL ,
		[29] SecurityParameters
		    -- DEFAULT {} ,
		    OPTIONAL ,
        requestor
                [28] DistinguishedName
                    OPTIONAL ,
                [27] OperationProgress
		    OPTIONAL ,
	aliasedRDNs
		[26] INTEGER
		    OPTIONAL ,
	extensions
		[25] SET OF
			Extension
		    OPTIONAL
        }

ListArgument
	::=
	CHOICE
	{
		ListArgumentData ,
		SEQUENCE
		{
			ListArgumentData ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}

ListResultData
        ::=
        CHOICE
        {
        listInfo
                SET
                {
                        DistinguishedName
                            OPTIONAL ,
                subordinates
                        [1] SET OF
                                SEQUENCE
                                {
                                        RelativeDistinguishedName ,
                                aliasEntry
                                        [0] BOOLEAN
                                            -- DEFAULT FALSE ,
                                            OPTIONAL ,
                                fromEntry
                                        [1] BOOLEAN
                                            -- DEFAULT TRUE
                                            OPTIONAL
                                } ,
                partialOutcomeQualifier
                        [2] PartialOutcomeQualifier
                            OPTIONAL ,
			[30] SecurityParameters
			    OPTIONAL ,
                performer
                        [29] DistinguishedName
                        OPTIONAL ,
                aliasDereferenced
                        [28] BOOLEAN
                            -- DEFAULT FALSE
                            OPTIONAL
                } ,
        uncorrelatedListInfo
                [0] SET OF
                        ListResult
        }

ListResult
	::=
	CHOICE
	{
		ListResultData ,
		SEQUENCE
		{
			ListResultData ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}

SearchArgumentData
        ::=
        SET
        {
        baseObject
                [0] Name ,
        subset
                [1] INTEGER
                {
                baseObject(0) ,
                oneLevel(1) ,
                wholeSubtree(2)
                }
                    -- DEFAULT baseObject ,
                    OPTIONAL ,
        filter
                [2] Filter
                    -- DEFAULT and {} ,
                    OPTIONAL ,
	searchAliases
		[3] BOOLEAN
		    -- DEFAULT TRUE ,
		    OPTIONAL ,
        selection
                [4] EntryInformationSelection
                    -- DEFAULT {} ,
                    OPTIONAL ,
                [30] ServiceControls
                    -- DEFAULT {} ,
                    OPTIONAL ,
		[29] SecurityParameters
		    -- DEFAULT {} ,
		    OPTIONAL ,
        requestor
                [28] DistinguishedName
                    OPTIONAL ,
                [27] OperationProgress
		    OPTIONAL ,
	aliasedRDNs
		[26] INTEGER
		    OPTIONAL ,
	extensions
		[25] SET OF
			Extension
		    OPTIONAL
        }

SearchArgument
	::=
	CHOICE
	{
		SearchArgumentData ,
		SEQUENCE
		{
			SearchArgumentData ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}

SearchResultData
        ::=
        CHOICE
        {
        searchInfo
                SET
                {
                        DistinguishedName
                            OPTIONAL ,
                entries
                        [0] SET OF
                                EntryInformation ,
                partialOutcomeQualifier
                        [2] PartialOutcomeQualifier
                            OPTIONAL ,
			[30] SecurityParameters
			    OPTIONAL ,
                performer
                        [29] DistinguishedName
                            OPTIONAL ,
                aliasDereferenced
                        [28] BOOLEAN
                            -- DEFAULT FALSE
                            OPTIONAL
                } ,
        uncorrelatedSearchInfo
                [0] SET OF
                        SearchResult
        }

SearchResult
	::=
	CHOICE
	{
		SearchResultData ,
		SEQUENCE
		{
			SearchResultData ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}

AddEntryArgumentData
        ::=
        SET
        {
        object
                [0] DistinguishedName ,
        entry
                [1] SET OF
                        Attribute ,
                [30] ServiceControls
                    -- DEFAULT {} ,
                    OPTIONAL ,
		[29] SecurityParameters
		    -- DEFAULT {} ,
		    OPTIONAL ,
        requestor
                [28] DistinguishedName
                    OPTIONAL ,
                [27] OperationProgress
		    OPTIONAL ,
	aliasedRDNs
		[26] INTEGER
		    OPTIONAL ,
	extensions
		[25] SET OF
			Extension
		    OPTIONAL
        }

AddEntryArgument
	::=
	CHOICE
	{
		AddEntryArgumentData ,
		SEQUENCE
		{
			AddEntryArgumentData ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}

AddEntryResult ::= NULL

RemoveEntryArgumentData
        ::=
        SET
        {
        object
                [0] DistinguishedName ,
                [30] ServiceControls
                    -- DEFAULT {} ,
                    OPTIONAL ,
		[29] SecurityParameters
		    -- DEFAULT {} ,
		    OPTIONAL ,
        requestor
                [28] DistinguishedName
                    OPTIONAL ,
                [27] OperationProgress
		    OPTIONAL ,
	aliasedRDNs
		[26] INTEGER
		    OPTIONAL ,
	extensions
		[25] SET OF
			Extension
		    OPTIONAL
        }

RemoveEntryArgument
	::=
	CHOICE
	{
		RemoveEntryArgumentData ,
		SEQUENCE
		{
			RemoveEntryArgumentData ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}

RemoveEntryResult ::= NULL

ModifyEntryArgumentData
        ::=
        SET
        {
        object
                [0] DistinguishedName ,
        changes
                [1] SEQUENCE OF
                        EntryModification ,
                [30] ServiceControls
                    -- DEFAULT {} ,
                    OPTIONAL ,
		[29] SecurityParameters
		    -- DEFAULT {} ,
		    OPTIONAL ,
        requestor
                [28] DistinguishedName
                    OPTIONAL ,
                [27] OperationProgress
		    OPTIONAL ,
	aliasedRDNs
		[26] INTEGER
		    OPTIONAL ,
	extensions
		[25] SET OF
			Extension
		    OPTIONAL
        }

ModifyEntryArgument
	::=
	CHOICE
	{
		ModifyEntryArgumentData ,
		SEQUENCE
		{
			ModifyEntryArgumentData ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}

ModifyEntryResult ::= NULL

ModifyRDNArgumentData
        ::=
        SET
        {
        object
                [0] DistinguishedName ,
        newRDN
                [1] RelativeDistinguishedName ,
        deleteRDN
                [2] BOOLEAN
                    -- DEFAULT FALSE ,
                    OPTIONAL ,
                [30] ServiceControls
                    -- DEFAULT {} ,
                    OPTIONAL ,
		[29] SecurityParameters
		    -- DEFAULT {} ,
		    OPTIONAL ,
        requestor
                [28] DistinguishedName
                    OPTIONAL ,
                [27] OperationProgress
		    OPTIONAL ,
	aliasedRDNs
		[26] INTEGER
		    OPTIONAL ,
	extensions
		[25] SET OF
			Extension
		    OPTIONAL
        }

ModifyRDNArgument
	::=
	CHOICE
	{
		ModifyRDNArgumentData ,
		SEQUENCE
		{
			ModifyRDNArgumentData ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}

ModifyRDNResult ::= NULL

DirectoryBindError
        ::=
        SET
        {
        versions
                [0] Versions
                    -- DEFAULT v1988 ,
                    OPTIONAL ,
                CHOICE
                {
                serviceError
                        [1] ServiceProblem ,
                securityError
                        [2] SecurityProblem
                }
        }

AbandonedParm ::= NULL

AbandonFailedParm
        ::=
        SET
        {
        problem
                [0] AbandonProblem ,
        operation
                [1] InvokeID
        }

AttributeErrorParm
        ::=
        SET
        {
        object
                [0] Name ,
        problems
                [1] SET OF
                        SEQUENCE
                        {
                        problem
                                [0] AttributeProblem ,
                        type
                                [1] AttributeType ,
                        value
                                [2] AttributeValue
                                    OPTIONAL
                        }
        }

NameErrorParm
        ::=
        SET
        {
        problem
                [0] NameProblem ,
        matched
                [1] Name
        }

ReferralParm
        ::=
        SET
        {
        candidate
                [0] ContinuationReference
        }

SecurityErrorParm
        ::=
        SET
        {
        problem
                [0] SecurityProblem
        }

ServiceErrorParm
        ::=
        SET
        {
        problem
                [0] ServiceProblem
        }

UpdateErrorParm
        ::=
        SET
        {
        problem
                [0] UpdateProblem
        }

END