1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
TConstrChoice DEFINITIONS ::=
BEGIN
FilterItem ::= CHOICE {
equality [0] AttributeValueAssertion,
substrings [1] SEQUENCE {
type ATTRIBUTE.&id({SupportedAttributes}),
strings SEQUENCE OF CHOICE {
initial [0] ATTRIBUTE.&Type
({SupportedAttributes}{@substrings.type}),
any [1] ATTRIBUTE.&Type
({SupportedAttributes}{@substrings.type}),
final [2] ATTRIBUTE.&Type
({SupportedAttributes}{@substrings.type}) }},
greaterOrEqual [2] AttributeValueAssertion,
lessOrEqual [3] AttributeValueAssertion,
present [4] AttributeType,
approximateMatch [5] AttributeValueAssertion,
extensibleMatch [6] MatchingRuleAssertion }
AttributeValueAssertion ::= SEQUENCE {
type ATTRIBUTE.&id({SupportedAttributes}),
assertion ATTRIBUTE.&equality-match.&AssertionType
({SupportedAttributes}{@type}) }
MatchingRuleAssertion ::= SEQUENCE {
type MATCHING-RULE.&id({MatchingRules}),
assertion MATCHING-RULE.&AssertionType ({MatchingRules}{@type})
}
AttributeType ::= INTEGER(0..127)
ATTRIBUTE ::= CLASS {
&derivation ATTRIBUTE OPTIONAL,
&Type OPTIONAL,
&equality-match MATCHING-RULE OPTIONAL,
&ordering-match MATCHING-RULE OPTIONAL,
&substrings-match MATCHING-RULE OPTIONAL,
&single-valued BOOLEAN DEFAULT FALSE,
&collective BOOLEAN DEFAULT FALSE,
&no-user-modification BOOLEAN DEFAULT FALSE,
&usage Attribute-Usage DEFAULT userApplications,
&id OBJECT IDENTIFIER UNIQUE }
WITH SYNTAX {
[SUBTYPE OF &derivation]
[WITH SYNTAX &Type]
[EQUALITY MATCHING RULE &equality-match]
[ORDERING MATCHING RULE &ordering-match]
[SUBSTRINGS MATCHING RULE &substrings-match]
[SINGLE VALUE &single-valued]
[COLLECTIVE &collective]
[NO USER MODIFICATION &no-user-modification]
[USAGE &usage]
ID &id }
Attribute-Usage ::= ENUMERATED { userApplications(0),
directoryOperation(1), distributedOperation(2),
dSAOperation(3) }
surname ATTRIBUTE ::= { -- family name
SUBTYPE OF name
WITH SYNTAX DirectoryString
ID id-at-surname }
givenName ATTRIBUTE ::= { -- first name
SUBTYPE OF name
WITH SYNTAX DirectoryString
ID id-at-givenName }
countryName ATTRIBUTE ::= { -- country
SUBTYPE OF name
WITH SYNTAX PrintableString (SIZE (2)) -- [ISO3166] codes
SINGLE VALUE TRUE
ID id-at-countryName}
SupportedAttributes ATTRIBUTE ::=
{surname | givenName | countryName}
-- id-at-surname DirectoryString ::= universalString:"SureName"
id-at-surname OBJECT IDENTIFIER ::= {2 4}
-- id-at-givenName DirectoryString ::= printableString:"GivenName"
id-at-givenName OBJECT IDENTIFIER ::= {2 5}
-- id-at-countryName PrintableString (SIZE (2)) ::= "CN"
id-at-countryName OBJECT IDENTIFIER ::= {2 6}
MATCHING-RULE ::= CLASS {
&AssertionType OPTIONAL,
&id OBJECT IDENTIFIER UNIQUE }
WITH SYNTAX {
[SYNTAX &AssertionType]
ID &id }
MatchingRules MATCHING-RULE ::= {
caseIgnoreMatch | booleanMatch | integerMatch }
LessMatchingRules MATCHING-RULE ::= {
MatchingRules EXCEPT caseIgnoreMatch }
ExtensibleMatchingRules MATCHING-RULE ::= {
caseIgnoreMatch | booleanMatch | integerMatch, ... }
name ATTRIBUTE ::= {
WITH SYNTAX DirectoryString
EQUALITY MATCHING RULE caseIgnoreMatch
ID id-name }
DirectoryString ::= CHOICE {
teletexString TeletexString (SIZE (1..maxSize)),
printableString PrintableString (SIZE (1..maxSize)),
universalString UniversalString (SIZE (1..maxSize)),
bmpString BMPString (SIZE (1..maxSize))
-- utf8String UTF8String (SIZE (1..maxSize))
}
maxSize INTEGER ::= 25
caseIgnoreMatch MATCHING-RULE ::= {
SYNTAX DirectoryString
ID id-caseIgnoreMatch
}
booleanMatch MATCHING-RULE ::= {
SYNTAX BOOLEAN
ID id-booleanMatch
}
integerMatch MATCHING-RULE ::= {
SYNTAX INTEGER
ID id-integerMatch
}
id-mr OBJECT IDENTIFIER ::=
{2 5 11}
id-name OBJECT IDENTIFIER ::= {2 5 11 5}
id-caseIgnoreMatch OBJECT IDENTIFIER ::= {2 5 11 2}
id-booleanMatch OBJECT IDENTIFIER ::= {2 5 11 13}
id-integerMatch OBJECT IDENTIFIER ::= {2 5 11 14}
--{joint-iso-itu-t ds(5) matchingRule(13)}
-- test code for OTP-4248
NOTUNIQUE ::= CLASS {
&value INTEGER,
&Type
}
WITH SYNTAX {
VALUE &value
TYPE &Type
}
nuObject NOTUNIQUE ::= {VALUE 3 TYPE FilterItem}
NuObjectSet NOTUNIQUE ::= {nuObject}
Seq ::= SEQUENCE {
a NOTUNIQUE.&value ({NuObjectSet}),
b NOTUNIQUE.&Type ({NuObjectSet}{@a})
}
END
|
