aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/doc
diff options
context:
space:
mode:
authorDavid M. Syzdek <david@syzdek.net>2019-11-19 18:02:17 -0900
committerDavid M. Syzdek <david@syzdek.net>2019-11-19 18:02:17 -0900
commit669460c168d7dd86dc2637e84126521da8d956c0 (patch)
tree4627596e672574bc295d913cae7e9649c1092fec /doc
parente2f40d6b426bd9887a78b8d9257c0674354ea1ea (diff)
downloadldap-utils-669460c168d7dd86dc2637e84126521da8d956c0.tar.gz
ldap-utils-669460c168d7dd86dc2637e84126521da8d956c0.tar.bz2
ldap-utils-669460c168d7dd86dc2637e84126521da8d956c0.tar.xz
ldap-utils-669460c168d7dd86dc2637e84126521da8d956c0.zip
oidspecs: moving OID specifications from lib/libldapschema/specs to doc/oidspecs
Diffstat (limited to 'doc')
-rw-r--r--doc/oidspecs/rfc/rfc4517.oidspec3886
-rw-r--r--doc/oidspecs/template.oidspec31
2 files changed, 3917 insertions, 0 deletions
diff --git a/doc/oidspecs/rfc/rfc4517.oidspec b/doc/oidspecs/rfc/rfc4517.oidspec
new file mode 100644
index 0000000..6a31d92
--- /dev/null
+++ b/doc/oidspecs/rfc/rfc4517.oidspec
@@ -0,0 +1,3886 @@
1{
2 // RFC 4512 LDAP Models June 2006
3 //
4 // 4.1.2. Attribute Types
5 //
6 // Attribute Type definitions are written according to the ABNF:
7 //
8 // AttributeTypeDescription = LPAREN WSP
9 // numericoid ; object identifier
10 // [ SP "NAME" SP qdescrs ] ; short names (descriptors)
11 // [ SP "DESC" SP qdstring ] ; description
12 // [ SP "OBSOLETE" ] ; not active
13 // [ SP "SUP" SP oid ] ; supertype
14 // [ SP "EQUALITY" SP oid ] ; equality matching rule
15 // [ SP "ORDERING" SP oid ] ; ordering matching rule
16 // [ SP "SUBSTR" SP oid ] ; substrings matching rule
17 // [ SP "SYNTAX" SP noidlen ] ; value syntax
18 // [ SP "SINGLE-VALUE" ] ; single-value
19 // [ SP "COLLECTIVE" ] ; collective
20 // [ SP "NO-USER-MODIFICATION" ] ; not user modifiable
21 // [ SP "USAGE" SP usage ] ; usage
22 // extensions WSP RPAREN ; extensions
23 //
24 // usage = "userApplications" / ; user
25 // "directoryOperation" / ; directory operational
26 // "distributedOperation" / ; DSA-shared operational
27 // "dSAOperation" ; DSA-specific operational
28 //
29 // where:
30 // <numericoid> is object identifier assigned to this attribute type;
31 // NAME <qdescrs> are short names (descriptors) identifying this
32 // attribute type;
33 // DESC <qdstring> is a short descriptive string;
34 // OBSOLETE indicates this attribute type is not active;
35 // SUP oid specifies the direct supertype of this type;
36 // EQUALITY, ORDERING, and SUBSTR provide the oid of the equality,
37 // ordering, and substrings matching rules, respectively;
38 // SYNTAX identifies value syntax by object identifier and may suggest
39 // a minimum upper bound;
40 // SINGLE-VALUE indicates attributes of this type are restricted to a
41 // single value;
42 // COLLECTIVE indicates this attribute type is collective
43 // [X.501][RFC3671];
44 // NO-USER-MODIFICATION indicates this attribute type is not user
45 // modifiable;
46 // USAGE indicates the application of this attribute type; and
47 // <extensions> describe extensions.
48 //
49 // Each attribute type description must contain at least one of the SUP
50 // or SYNTAX fields. If no SYNTAX field is provided, the attribute type
51 // description takes its value from the supertype.
52 //
53 // If SUP field is provided, the EQUALITY, ORDERING, and SUBSTRING
54 // fields, if not specified, take their value from the supertype.
55 //
56 // Usage of userApplications, the default, indicates that attributes of
57 // this type represent user information. That is, they are user
58 // attributes.
59 //
60 // A usage of directoryOperation, distributedOperation, or dSAOperation
61 // indicates that attributes of this type represent operational and/or
62 // administrative information. That is, they are operational
63 // attributes.
64 //
65 // directoryOperation usage indicates that the attribute of this type is
66 // a directory operational attribute. distributedOperation usage
67 // indicates that the attribute of this type is a DSA-shared usage
68 // operational attribute. dSAOperation usage indicates that the
69 // attribute of this type is a DSA-specific operational attribute.
70 //
71 // COLLECTIVE requires usage userApplications. Use of collective
72 // attribute types in LDAP is discussed in [RFC3671].
73 //
74 // NO-USER-MODIFICATION requires an operational usage.
75 //
76 // Note that the <AttributeTypeDescription> does not list the matching
77 // rules that can be used with that attribute type in an extensibleMatch
78 // search filter [RFC4511]. This is done using the 'matchingRuleUse'
79 // attribute described in Section 4.1.4.
80 //
81 // This document refines the schema description of X.501 by requiring
82 // that the SYNTAX field in an <AttributeTypeDescription> be a string
83 // representation of an object identifier for the LDAP string syntax
84 // definition, with an optional indication of the suggested minimum
85 // bound of a value of this attribute.
86 //
87 // A suggested minimum upper bound on the number of characters in a
88 // value with a string-based syntax, or the number of bytes in a value
89 // for all other syntaxes, may be indicated by appending this bound
90 // count inside of curly braces following the syntax's OBJECT IDENTIFIER
91 // in an Attribute Type Description. This bound is not part of the
92 // syntax name itself. For instance, "1.3.6.4.1.1466.0{64}" suggests
93 // that server implementations should allow a string to be 64 characters
94 // long, although they may allow longer strings. Note that a single
95 // character of the Directory String syntax may be encoded in more than
96 // one octet since UTF-8 [RFC3629] is a variable-length encoding.
97 //
98 //
99 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
100 //
101 // 3.3.1. Attribute Type Description
102 //
103 // A value of the Attribute Type Description syntax is the definition of
104 // an attribute type. The LDAP-specific encoding of a value of this
105 // syntax is defined by the <AttributeTypeDescription> rule in
106 // [RFC4512].
107 //
108 // For example, the following definition of the createTimestamp
109 // attribute type from [RFC4512] is also a value of the Attribute
110 // Type Description syntax. (Note: Line breaks have been added for
111 // readability; they are not part of the value when transferred in
112 // protocol.)
113 //
114 // ( 2.5.18.1 NAME 'createTimestamp'
115 // EQUALITY generalizedTimeMatch
116 // ORDERING generalizedTimeOrderingMatch
117 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.24
118 // SINGLE-VALUE NO-USER-MODIFICATION
119 // USAGE directoryOperation )
120 //
121 // The LDAP definition for the Attribute Type Description syntax is:
122 //
123 // ( 1.3.6.1.4.1.1466.115.121.1.3 DESC 'Attribute Type Description' )
124 //
125 // This syntax corresponds to the AttributeTypeDescription ASN.1 type
126 // from [X.501].
127 //
128 //
129 .oid = "1.3.6.1.4.1.1466.115.121.1.3",
130 .name = "AttributeTypeDescription",
131 .desc = "Attribute Type Description",
132 .flags = LDAPSCHEMA_O_READABLE | LDAPSCHEMA_O_COMMON_ABNF | LDAPSCHEMA_O_SCHEMA_ABNF,
133 .type = LDAPSCHEMA_SYNTAX,
134 .class = LDAPSCHEMA_CLASS_ASCII,
135 .def = "( 1.3.6.1.4.1.1466.115.121.1.3 DESC 'Attribute Type Description' )",
136 .abnf = "AttributeTypeDescription = LPAREN WSP\n"
137 " numericoid ; object identifier\n"
138 " [ SP \"NAME\" SP qdescrs ] ; short names (descriptors)\n"
139 " [ SP \"DESC\" SP qdstring ] ; description\n"
140 " [ SP \"OBSOLETE\" ] ; not active\n"
141 " [ SP \"SUP\" SP oid ] ; supertype\n"
142 " [ SP \"EQUALITY\" SP oid ] ; equality matching rule\n"
143 " [ SP \"ORDERING\" SP oid ] ; ordering matching rule\n"
144 " [ SP \"SUBSTR\" SP oid ] ; substrings matching rule\n"
145 " [ SP \"SYNTAX\" SP noidlen ] ; value syntax\n"
146 " [ SP \"SINGLE-VALUE\" ] ; single-value\n"
147 " [ SP \"COLLECTIVE\" ] ; collective\n"
148 " [ SP \"NO-USER-MODIFICATION\" ] ; not user modifiable\n"
149 " [ SP \"USAGE\" SP usage ] ; usage\n"
150 " extensions WSP RPAREN ; extensions\n"
151 "\n"
152 "usage = \"userApplications\" / ; user\n"
153 " \"directoryOperation\" / ; directory operational\n"
154 " \"distributedOperation\" / ; DSA-shared operational\n"
155 " \"dSAOperation\" ; DSA-specific operational\n",
156 .re_posix = NULL,
157 .re_pcre = NULL,
158 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
159 .spec_type = LDAPSCHEMA_SPEC_RFC,
160 .spec_name = "4517",
161 .spec_section = "3.3.1",
162 .spec_source = NULL,
163 .spec_vendor = "IETF",
164 .examples = (const char *[])
165 {
166 "( 2.5.18.1 NAME 'createTimestamp' EQUALITY generalizedTimeMatch ORDERING generalizedTimeOrderingMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 SINGLE-VALUE NO-USER-MODIFICATION USAGE directoryOperation )",
167 NULL,
168 },
169};
170
171
172
173{
174 //
175 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
176 //
177 // 3.3.2. Bit String
178 //
179 // A value of the Bit String syntax is a sequence of binary digits. The
180 // LDAP-specific encoding of a value of this syntax is defined by the
181 // following ABNF:
182 //
183 // BitString = SQUOTE *binary-digit SQUOTE "B"
184 // binary-digit = "0" / "1"
185 //
186 // The <SQUOTE> rule is defined in [RFC4512].
187 //
188 // Example:
189 // '0101111101'B
190 //
191 // The LDAP definition for the Bit String syntax is:
192 //
193 // ( 1.3.6.1.4.1.1466.115.121.1.6 DESC 'Bit String' )
194 //
195 // This syntax corresponds to the BIT STRING ASN.1 type from [ASN.1].
196 //
197 .oid = "1.3.6.1.4.1.1466.115.121.1.6",
198 .name = "BitString",
199 .desc = "Bit String",
200 .flags = LDAPSCHEMA_O_READABLE,
201 .type = LDAPSCHEMA_SYNTAX,
202 .class = LDAPSCHEMA_CLASS_ASCII,
203 .def = "( 1.3.6.1.4.1.1466.115.121.1.6 DESC 'Bit String' )",
204 .abnf = "BitString = SQUOTE *binary-digit SQUOTE \"B\"\n"
205 "SQUOTE = %x27 ; single quote (\"'\")\n"
206 "binary-digit = \"0\" / \"1\"\n",
207 .re_posix = "^('[01]{1,}'B)$",
208 .re_pcre = "^('[01]+'B)$",
209 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
210 .spec_type = LDAPSCHEMA_SPEC_RFC,
211 .spec_name = "4517",
212 .spec_section = "3.3.2",
213 .spec_source = NULL,
214 .spec_vendor = "IETF",
215 .examples = (const char *[])
216 {
217 "'0101111101'B",
218 NULL,
219 },
220};
221
222
223
224{
225 //
226 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
227 //
228 // 3.3.3. Boolean
229 //
230 // A value of the Boolean syntax is one of the Boolean values, true or
231 // false. The LDAP-specific encoding of a value of this syntax is
232 // defined by the following ABNF:
233 //
234 // Boolean = "TRUE" / "FALSE"
235 //
236 // The LDAP definition for the Boolean syntax is:
237 //
238 // ( 1.3.6.1.4.1.1466.115.121.1.7 DESC 'Boolean' )
239 //
240 // This syntax corresponds to the BOOLEAN ASN.1 type from [ASN.1].
241 //
242 .oid = "1.3.6.1.4.1.1466.115.121.1.7",
243 .name = "Boolean",
244 .desc = "Boolean",
245 .flags = LDAPSCHEMA_O_READABLE,
246 .type = LDAPSCHEMA_SYNTAX,
247 .class = LDAPSCHEMA_CLASS_ASCII,
248 .def = "( 1.3.6.1.4.1.1466.115.121.1.7 DESC 'Boolean' )",
249 .abnf = "Boolean = \"TRUE\" / \"FALSE\"",
250 .re_posix = "^(TRUE|FALSE)$",
251 .re_pcre = "^(TRUE|FALSE)$",
252 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
253 .spec_type = LDAPSCHEMA_SPEC_RFC,
254 .spec_name = "4517",
255 .spec_section = "3.3.3",
256 .spec_source = NULL,
257 .spec_vendor = "IETF",
258 .examples = (const char *[])
259 {
260 "TRUE",
261 "FALSE",
262 NULL,
263 },
264};
265
266
267
268{
269 //
270 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
271 //
272 // 3.3.4. Country String
273 //
274 // A value of the Country String syntax is one of the two-character
275 // codes from ISO 3166 [ISO3166] for representing a country. The LDAP-
276 // specific encoding of a value of this syntax is defined by the
277 // following ABNF:
278 //
279 // CountryString = 2(PrintableCharacter)
280 //
281 // The <PrintableCharacter> rule is defined in Section 3.2.
282 //
283 // Examples:
284 //
285 // US
286 // AU
287 //
288 // The LDAP definition for the Country String syntax is:
289 //
290 // ( 1.3.6.1.4.1.1466.115.121.1.11 DESC 'Country String' )
291 //
292 // This syntax corresponds to the following ASN.1 type from [X.520]:
293 //
294 // PrintableString (SIZE (2)) -- ISO 3166 codes only
295 //
296 .oid = "1.3.6.1.4.1.1466.115.121.1.11",
297 .name = "CountryString",
298 .desc = "Country String",
299 .flags = LDAPSCHEMA_O_READABLE | LDAPSCHEMA_O_COMMON_ABNF,
300 .type = LDAPSCHEMA_SYNTAX,
301 .class = LDAPSCHEMA_CLASS_ASCII,
302 .def = "( 1.3.6.1.4.1.1466.115.121.1.11 DESC 'Country String' )",
303 .abnf = "CountryString = 2(PrintableCharacter)\n"
304 "PrintableCharacter = ALPHA / DIGIT / SQUOTE / LPAREN / RPAREN /\n"
305 " PLUS / COMMA / HYPHEN / DOT / EQUALS / SLASH / COLON /\n"
306 " QUESTION / SPACE\n",
307 .re_posix = "^([-'()+,.=/:? a-zA-Z0-9]{2,2})$",
308 .re_pcre = "^([-'()+,.=/:? a-zA-Z0-9]{2,2})$",
309 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
310 .spec_type = LDAPSCHEMA_SPEC_RFC,
311 .spec_name = "4517",
312 .spec_section = "3.3.4",
313 .spec_source = NULL,
314 .spec_vendor = "IETF",
315 .examples = (const char *[])
316 {
317 "US",
318 "AU",
319 NULL,
320 },
321};
322
323
324
325{
326 //
327 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
328 //
329 // 3.3.5. Delivery Method
330 //
331 // A value of the Delivery Method syntax is a sequence of items that
332 // indicate, in preference order, the service(s) by which an entity is
333 // willing and/or capable of receiving messages. The LDAP-specific
334 // encoding of a value of this syntax is defined by the following ABNF:
335 //
336 // DeliveryMethod = pdm *( WSP DOLLAR WSP pdm )
337 //
338 // pdm = "any" / "mhs" / "physical" / "telex" / "teletex" /
339 // "g3fax" / "g4fax" / "ia5" / "videotex" / "telephone"
340 //
341 // The <WSP> and <DOLLAR> rules are defined in [RFC4512].
342 //
343 // Example:
344 // telephone $ videotex
345 //
346 // The LDAP definition for the Delivery Method syntax is:
347 //
348 // ( 1.3.6.1.4.1.1466.115.121.1.14 DESC 'Delivery Method' )
349 //
350 // This syntax corresponds to the following ASN.1 type from [X.520]:
351 //
352 // SEQUENCE OF INTEGER {
353 // any-delivery-method (0),
354 // mhs-delivery (1),
355 // physical-delivery (2),
356 // telex-delivery (3),
357 // teletex-delivery (4),
358 // g3-facsimile-delivery (5),
359 // g4-facsimile-delivery (6),
360 // ia5-terminal-delivery (7),
361 // videotex-delivery (8),
362 // telephone-delivery (9) }
363 //
364 .oid = "1.3.6.1.4.1.1466.115.121.1.14",
365 .name = "DeliveryMethod",
366 .desc = "Delivery Method",
367 .flags = LDAPSCHEMA_O_READABLE,
368 .type = LDAPSCHEMA_SYNTAX,
369 .class = LDAPSCHEMA_CLASS_ASCII,
370 .def = "( 1.3.6.1.4.1.1466.115.121.1.14 DESC 'Delivery Method' )",
371 .abnf = "DeliveryMethod = pdm *( WSP DOLLAR WSP pdm )\n"
372 "\n"
373 "pdm = \"any\" / \"mhs\" / \"physical\" / \"telex\" / \"teletex\" /\n"
374 " \"g3fax\" / \"g4fax\" / \"ia5\" / \"videotex\" / \"telephone\"\n"
375 "\n"
376 "WSP = 0*SPACE ; zero or more \" \"\n"
377 "DOLLAR = %x24 ; dollar sign (\"$\")\n",
378 .re_posix = "^((any|mhs|physical|telex|teletex|g3fax|g4fax|ia5|videotex|videotex)([ ]{0,}[$][ ]{0,}(any|mhs|physical|telex|teletex|g3fax|g4fax|ia5|videotex|videotex)){0,})$",
379 .re_pcre = "^((any|mhs|physical|telex|teletex|g3fax|g4fax|ia5|videotex|videotex)([ ]*[$][ ]*(any|mhs|physical|telex|teletex|g3fax|g4fax|ia5|videotex|videotex))*)$",
380 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
381 .spec_type = LDAPSCHEMA_SPEC_RFC,
382 .spec_name = "4517",
383 .spec_section = "3.3.5",
384 .spec_source = NULL,
385 .spec_vendor = "IETF",
386 .examples = (const char *[])
387 {
388 "any",
389 "physical $ telephone",
390 NULL,
391 },
392};
393
394
395
396{
397 //
398 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
399 //
400 // 3.3.6. Directory String
401 //
402 // A value of the Directory String syntax is a string of one or more
403 // arbitrary characters from the Universal Character Set (UCS) [UCS]. A
404 // zero-length character string is not permitted. The LDAP-specific
405 // encoding of a value of this syntax is the UTF-8 encoding [RFC3629] of
406 // the character string. Such encodings conform to the following ABNF:
407 //
408 // DirectoryString = 1*UTF8
409 //
410 // The <UTF8> rule is defined in [RFC4512].
411 //
412 // Example:
413 // This is a value of Directory String containing #!%#@.
414 //
415 // Servers and clients MUST be prepared to receive arbitrary UCS code
416 // points, including code points outside the range of printable ASCII
417 // and code points not presently assigned to any character.
418 //
419 // Attribute type definitions using the Directory String syntax should
420 // not restrict the format of Directory String values, e.g., by
421 // requiring that the character string conforms to specific patterns
422 // described by ABNF. A new syntax should be defined in such cases.
423 //
424 // The LDAP definition for the Directory String syntax is:
425 //
426 // ( 1.3.6.1.4.1.1466.115.121.1.15 DESC 'Directory String' )
427 //
428 // This syntax corresponds to the DirectoryString parameterized ASN.1
429 // type from [X.520].
430 //
431 // The DirectoryString ASN.1 type allows a choice between the
432 // TeletexString, PrintableString, or UniversalString ASN.1 types from
433 // [ASN.1]. However, note that the chosen alternative is not indicated
434 // in the LDAP-specific encoding of a Directory String value.
435 //
436 // Implementations that convert Directory String values from the LDAP-
437 // specific encoding to the BER encoding used by X.500 must choose an
438 // alternative that permits the particular characters in the string and
439 // must convert the characters from the UTF-8 encoding into the
440 // character encoding of the chosen alternative. When converting
441 // Directory String values from the BER encoding to the LDAP-specific
442 // encoding, the characters must be converted from the character
443 // encoding of the chosen alternative into the UTF-8 encoding. These
444 // conversions SHOULD be done in a manner consistent with the Transcode
445 // step of the string preparation algorithms [RFC4518] for LDAP.
446 //
447 .oid = "1.3.6.1.4.1.1466.115.121.1.15",
448 .name = "DirectoryString",
449 .desc = "Directory String",
450 .flags = LDAPSCHEMA_O_READABLE,
451 .type = LDAPSCHEMA_SYNTAX,
452 .class = LDAPSCHEMA_CLASS_UTF8,
453 .def = "( 1.3.6.1.4.1.1466.115.121.1.15 DESC 'Directory String' )",
454 .abnf = "DirectoryString = 1*UTF8\n"
455 "\n"
456 "UTF8 = UTF1 / UTFMB\n"
457 "UTFMB = UTF2 / UTF3 / UTF4\n"
458 "UTF0 = %x80-BF\n"
459 "UTF1 = %x00-7F\n"
460 "UTF2 = %xC2-DF UTF0\n"
461 "UTF3 = %xE0 %xA0-BF UTF0 / %xE1-EC 2(UTF0) /\n"
462 " %xED %x80-9F UTF0 / %xEE-EF 2(UTF0)\n"
463 "UTF4 = %xF0 %x90-BF 2(UTF0) / %xF1-F3 3(UTF0) /\n"
464 " %xF4 %x80-8F 2(UTF0)\n",
465 .re_posix = NULL,
466 .re_pcre = NULL,
467 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
468 .spec_type = LDAPSCHEMA_SPEC_RFC,
469 .spec_name = "4517",
470 .spec_section = "3.3.6",
471 .spec_source = NULL,
472 .spec_vendor = "IETF",
473 .examples = (const char *[])
474 {
475 "This is a value of Directory String containing #!%#@.",
476 NULL,
477 },
478};
479
480
481
482{
483 //
484 // RFC 4512 LDAP Models June 2006
485 //
486 // 4.1.6. DIT Content Rules
487 //
488 // A DIT content rule is a "rule governing the content of entries of a
489 // particular structural object class" [X.501].
490 //
491 // For DIT entries of a particular structural object class, a DIT
492 // content rule specifies which auxiliary object classes the entries are
493 // allowed to belong to and which additional attributes (by type) are
494 // required, allowed, or not allowed to appear in the entries.
495 //
496 // The list of precluded attributes cannot include any attribute listed
497 // as mandatory in the rule, the structural object class, or any of the
498 // allowed auxiliary object classes.
499 //
500 // Each content rule is identified by the object identifier, as well as
501 // any short names (descriptors), of the structural object class it
502 // applies to.
503 //
504 // An entry may only belong to auxiliary object classes listed in the
505 // governing content rule.
506 //
507 // An entry must contain all attributes required by the object classes
508 // the entry belongs to as well as all attributes required by the
509 // governing content rule.
510 //
511 // An entry may contain any non-precluded attributes allowed by the
512 // object classes the entry belongs to as well as all attributes allowed
513 // by the governing content rule.
514 //
515 // An entry cannot include any attribute precluded by the governing
516 // content rule.
517 //
518 // An entry is governed by (if present and active in the subschema) the
519 // DIT content rule that applies to the structural object class of the
520 // entry (see Section 2.4.2). If no active rule is present for the
521 // entry's structural object class, the entry's content is governed by
522 // the structural object class (and possibly other aspects of user and
523 // system schema). DIT content rules for superclasses of the structural
524 // object class of an entry are not applicable to that entry.
525 //
526 // DIT content rule descriptions are written according to the ABNF:
527 //
528 // DITContentRuleDescription = LPAREN WSP
529 // numericoid ; object identifier
530 // [ SP "NAME" SP qdescrs ] ; short names (descriptors)
531 // [ SP "DESC" SP qdstring ] ; description
532 // [ SP "OBSOLETE" ] ; not active
533 // [ SP "AUX" SP oids ] ; auxiliary object classes
534 // [ SP "MUST" SP oids ] ; attribute types
535 // [ SP "MAY" SP oids ] ; attribute types
536 // [ SP "NOT" SP oids ] ; attribute types
537 // extensions WSP RPAREN ; extensions
538 //
539 // where:
540 // <numericoid> is the object identifier of the structural object
541 // class associated with this DIT content rule;
542 // NAME <qdescrs> are short names (descriptors) identifying this DIT
543 // content rule;
544 // DESC <qdstring> is a short descriptive string;
545 // OBSOLETE indicates this DIT content rule use is not active;
546 // AUX specifies a list of auxiliary object classes that entries
547 // subject to this DIT content rule may belong to;
548 //
549 // MUST, MAY, and NOT specify lists of attribute types that are
550 // required, allowed, or precluded, respectively, from appearing
551 // in entries subject to this DIT content rule; and
552 // <extensions> describe extensions.
553 //
554 //
555 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
556 //
557 // 3.3.7. DIT Content Rule Description
558 //
559 // A value of the DIT Content Rule Description syntax is the definition
560 // of a DIT (Directory Information Tree) content rule. The LDAP-
561 // specific encoding of a value of this syntax is defined by the
562 // <DITContentRuleDescription> rule in [RFC4512].
563 //
564 // Example:
565 // ( 2.5.6.4 DESC 'content rule for organization'
566 // NOT ( x121Address $ telexNumber ) )
567 //
568 // Note: A line break has been added for readability; it is not part
569 // of the value.
570 //
571 // The LDAP definition for the DIT Content Rule Description syntax is:
572 //
573 // ( 1.3.6.1.4.1.1466.115.121.1.16
574 // DESC 'DIT Content Rule Description' )
575 //
576 // This syntax corresponds to the DITContentRuleDescription ASN.1 type
577 // from [X.501].
578 //
579 .oid = "1.3.6.1.4.1.1466.115.121.1.16",
580 .name = "DITContentRuleDescription",
581 .desc = "DIT Content Rule Description",
582 .flags = LDAPSCHEMA_O_READABLE | LDAPSCHEMA_O_COMMON_ABNF | LDAPSCHEMA_O_SCHEMA_ABNF,
583 .type = LDAPSCHEMA_SYNTAX,
584 .class = LDAPSCHEMA_CLASS_ASCII,
585 .def = "( 1.3.6.1.4.1.1466.115.121.1.16 DESC 'DIT Content Rule Description' )",
586 .abnf = "DITContentRuleDescription = LPAREN WSP\n"
587 " numericoid ; object identifier\n"
588 " [ SP \"NAME\" SP qdescrs ] ; short names (descriptors)\n"
589 " [ SP \"DESC\" SP qdstring ] ; description\n"
590 " [ SP \"OBSOLETE\" ] ; not active\n"
591 " [ SP \"AUX\" SP oids ] ; auxiliary object classes\n"
592 " [ SP \"MUST\" SP oids ] ; attribute types\n"
593 " [ SP \"MAY\" SP oids ] ; attribute types\n"
594 " [ SP \"NOT\" SP oids ] ; attribute types\n"
595 " extensions WSP RPAREN ; extensions\n",
596 .re_posix = NULL,
597 .re_pcre = NULL,
598 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
599 .spec_type = LDAPSCHEMA_SPEC_RFC,
600 .spec_name = "4517",
601 .spec_section = "3.3.7",
602 .spec_source = NULL,
603 .spec_vendor = "IETF",
604 .examples = NULL,
605};
606
607
608
609{
610 //
611 // RFC 4512 LDAP Models June 2006
612 //
613 // 4.1.7.1. DIT Structure Rules
614 //
615 // A DIT structure rule is a "rule governing the structure of the DIT by
616 // specifying a permitted superior to subordinate entry relationship. A
617 // structure rule relates a name form, and therefore a structural object
618 // class, to superior structure rules. This permits entries of the
619 // structural object class identified by the name form to exist in the
620 // DIT as subordinates to entries governed by the indicated superior
621 // structure rules" [X.501].
622 //
623 // DIT structure rule descriptions are written according to the ABNF:
624 //
625 // DITStructureRuleDescription = LPAREN WSP
626 // ruleid ; rule identifier
627 // [ SP "NAME" SP qdescrs ] ; short names (descriptors)
628 // [ SP "DESC" SP qdstring ] ; description
629 // [ SP "OBSOLETE" ] ; not active
630 // SP "FORM" SP oid ; NameForm
631 // [ SP "SUP" ruleids ] ; superior rules
632 // extensions WSP RPAREN ; extensions
633 //
634 // ruleids = ruleid / ( LPAREN WSP ruleidlist WSP RPAREN )
635 // ruleidlist = ruleid *( SP ruleid )
636 // ruleid = number
637 //
638 // where:
639 // <ruleid> is the rule identifier of this DIT structure rule;
640 // NAME <qdescrs> are short names (descriptors) identifying this DIT
641 // structure rule;
642 // DESC <qdstring> is a short descriptive string;
643 // OBSOLETE indicates this DIT structure rule use is not active;
644 // FORM is specifies the name form associated with this DIT structure
645 // rule;
646 // SUP identifies superior rules (by rule id); and
647 // <extensions> describe extensions.
648 //
649 // If no superior rules are identified, the DIT structure rule applies
650 // to an autonomous administrative point (e.g., the root vertex of the
651 // subtree controlled by the subschema) [X.501].
652 //
653 //
654 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
655 //
656 // 3.3.8. DIT Structure Rule Description
657 //
658 // A value of the DIT Structure Rule Description syntax is the
659 // definition of a DIT structure rule. The LDAP-specific encoding of a
660 // value of this syntax is defined by the <DITStructureRuleDescription>
661 // rule in [RFC4512].
662 //
663 // Example:
664 // ( 2 DESC 'organization structure rule' FORM 2.5.15.3 )
665 //
666 // The LDAP definition for the DIT Structure Rule Description syntax is:
667 //
668 // ( 1.3.6.1.4.1.1466.115.121.1.17
669 // DESC 'DIT Structure Rule Description' )
670 //
671 // This syntax corresponds to the DITStructureRuleDescription ASN.1 type
672 // from [X.501].
673 .oid = "1.3.6.1.4.1.1466.115.121.1.17",
674 .name = "DITStructureRuleDescription",
675 .desc = "DIT Structure Rule Description",
676 .flags = LDAPSCHEMA_O_READABLE | LDAPSCHEMA_O_COMMON_ABNF | LDAPSCHEMA_O_SCHEMA_ABNF,
677 .type = LDAPSCHEMA_SYNTAX,
678 .class = LDAPSCHEMA_CLASS_ASCII,
679 .def = "( 1.3.6.1.4.1.1466.115.121.1.17 DESC 'DIT Structure Rule Description' )",
680 .abnf = "DITStructureRuleDescription = LPAREN WSP\n"
681 " ruleid ; rule identifier\n"
682 " [ SP \"NAME\" SP qdescrs ] ; short names (descriptors)\n"
683 " [ SP \"DESC\" SP qdstring ] ; description\n"
684 " [ SP \"OBSOLETE\" ] ; not active\n"
685 " SP \"FORM\" SP oid ; NameForm\n"
686 " [ SP \"SUP\" ruleids ] ; superior rules\n"
687 " extensions WSP RPAREN ; extensions\n"
688 "\n"
689 "ruleids = ruleid / ( LPAREN WSP ruleidlist WSP RPAREN )\n"
690 "ruleidlist = ruleid *( SP ruleid )\n"
691 "ruleid = number\n",
692 .re_posix = NULL,
693 .re_pcre = NULL,
694 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
695 .spec_type = LDAPSCHEMA_SPEC_RFC,
696 .spec_name = "4517",
697 .spec_section = "3.3.8",
698 .spec_source = NULL,
699 .spec_vendor = "IETF",
700 .examples = NULL,
701};
702
703
704
705{
706 //
707 // RFC 4514 LDAP: Distinguished Names June 2006
708 //
709 // 3. Parsing a String Back to a Distinguished Name
710 //
711 // The string representation of Distinguished Names is restricted to
712 // UTF-8 [RFC3629] encoded Unicode [Unicode] characters. The structure
713 // of this string representation is specified using the following
714 // Augmented BNF [RFC4234] grammar:
715 //
716 // distinguishedName = [ relativeDistinguishedName
717 // *( COMMA relativeDistinguishedName ) ]
718 // relativeDistinguishedName = attributeTypeAndValue
719 // *( PLUS attributeTypeAndValue )
720 // attributeTypeAndValue = attributeType EQUALS attributeValue
721 // attributeType = descr / numericoid
722 // attributeValue = string / hexstring
723 //
724 // ; The following characters are to be escaped when they appear
725 // ; in the value to be encoded: ESC, one of <escaped>, leading
726 // ; SHARP or SPACE, trailing SPACE, and NULL.
727 // string = [ ( leadchar / pair ) [ *( stringchar / pair )
728 // ( trailchar / pair ) ] ]
729 //
730 // leadchar = LUTF1 / UTFMB
731 // LUTF1 = %x01-1F / %x21 / %x24-2A / %x2D-3A /
732 // %x3D / %x3F-5B / %x5D-7F
733 //
734 // trailchar = TUTF1 / UTFMB
735 // TUTF1 = %x01-1F / %x21 / %x23-2A / %x2D-3A /
736 // %x3D / %x3F-5B / %x5D-7F
737 //
738 // stringchar = SUTF1 / UTFMB
739 // SUTF1 = %x01-21 / %x23-2A / %x2D-3A /
740 // %x3D / %x3F-5B / %x5D-7F
741 //
742 // pair = ESC ( ESC / special / hexpair )
743 // special = escaped / SPACE / SHARP / EQUALS
744 // escaped = DQUOTE / PLUS / COMMA / SEMI / LANGLE / RANGLE
745 // hexstring = SHARP 1*hexpair
746 // hexpair = HEX HEX
747 //
748 // where the productions <descr>, <numericoid>, <COMMA>, <DQUOTE>,
749 // <EQUALS>, <ESC>, <HEX>, <LANGLE>, <NULL>, <PLUS>, <RANGLE>, <SEMI>,
750 // <SPACE>, <SHARP>, and <UTFMB> are defined in [RFC4512].
751 //
752 // Each <attributeType>, either a <descr> or a <numericoid>, refers to
753 // an attribute type of an attribute value assertion (AVA). The
754 // <attributeType> is followed by an <EQUALS> and an <attributeValue>.
755 // The <attributeValue> is either in <string> or <hexstring> form.
756 //
757 // If in <string> form, a LDAP string representation asserted value can
758 // be obtained by replacing (left to right, non-recursively) each <pair>
759 // appearing in the <string> as follows:
760 //
761 // replace <ESC><ESC> with <ESC>;
762 // replace <ESC><special> with <special>;
763 // replace <ESC><hexpair> with the octet indicated by the <hexpair>.
764 //
765 // If in <hexstring> form, a BER representation can be obtained from
766 // converting each <hexpair> of the <hexstring> to the octet indicated
767 // by the <hexpair>.
768 //
769 // There is one or more attribute value assertions, separated by <PLUS>,
770 // for a relative distinguished name.
771 //
772 // There is zero or more relative distinguished names, separated by
773 // <COMMA>, for a distinguished name.
774 //
775 // Implementations MUST recognize AttributeType name strings
776 // (descriptors) listed in the following table, but MAY recognize other
777 // name strings.
778 //
779 //
780 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
781 //
782 // 3.3.9. DN
783 //
784 // A value of the DN syntax is the (purported) distinguished name (DN)
785 // of an entry [RFC4512]. The LDAP-specific encoding of a value of this
786 // syntax is defined by the <distinguishedName> rule from the string
787 // representation of distinguished names [RFC4514].
788 //
789 // Examples (from [RFC4514]):
790 // UID=jsmith,DC=example,DC=net
791 // OU=Sales+CN=J. Smith,DC=example,DC=net
792 // CN=John Smith\, III,DC=example,DC=net
793 // CN=Before\0dAfter,DC=example,DC=net
794 // 1.3.6.1.4.1.1466.0=#04024869,DC=example,DC=com
795 // CN=Lu\C4\8Di\C4\87
796 //
797 // The LDAP definition for the DN syntax is:
798 //
799 // ( 1.3.6.1.4.1.1466.115.121.1.12 DESC 'DN' )
800 //
801 // The DN syntax corresponds to the DistinguishedName ASN.1 type from
802 // [X.501]. Note that a BER encoded distinguished name (as used by
803 // X.500) re-encoded into the LDAP-specific encoding is not necessarily
804 // reversible to the original BER encoding since the chosen string type
805 // in any DirectoryString components of the distinguished name is not
806 // indicated in the LDAP-specific encoding of the distinguished name
807 // (see Section 3.3.6).
808 //
809 .oid = "1.3.6.1.4.1.1466.115.121.1.12",
810 .name = "distinguishedName",
811 .desc = "DN",
812 .flags = LDAPSCHEMA_O_READABLE | LDAPSCHEMA_O_COMMON_ABNF,
813 .type = LDAPSCHEMA_SYNTAX,
814 .class = LDAPSCHEMA_CLASS_UTF8,
815 .def = "( 1.3.6.1.4.1.1466.115.121.1.12 DESC 'DN' )",
816 .abnf = "distinguishedName = [ relativeDistinguishedName\n"
817 " *( COMMA relativeDistinguishedName ) ]\n"
818 "relativeDistinguishedName = attributeTypeAndValue\n"
819 " *( PLUS attributeTypeAndValue )\n"
820 "attributeTypeAndValue = attributeType EQUALS attributeValue\n"
821 "attributeType = descr / numericoid\n"
822 "attributeValue = string / hexstring\n"
823 "\n"
824 "; The following characters are to be escaped when they appear\n"
825 "; in the value to be encoded: ESC, one of <escaped>, leading\n"
826 "; SHARP or SPACE, trailing SPACE, and NULL.\n"
827 "string = [ ( leadchar / pair ) [ *( stringchar / pair )\n"
828 " ( trailchar / pair ) ] ]\n"
829 "\n"
830 "leadchar = LUTF1 / UTFMB\n"
831 "LUTF1 = %x01-1F / %x21 / %x24-2A / %x2D-3A /\n"
832 " %x3D / %x3F-5B / %x5D-7F\n"
833 "\n"
834 "trailchar = TUTF1 / UTFMB\n"
835 "TUTF1 = %x01-1F / %x21 / %x23-2A / %x2D-3A /\n"
836 " %x3D / %x3F-5B / %x5D-7F\n"
837 "\n"
838 "stringchar = SUTF1 / UTFMB\n"
839 "SUTF1 = %x01-21 / %x23-2A / %x2D-3A /\n"
840 " %x3D / %x3F-5B / %x5D-7F\n"
841 "\n"
842 "pair = ESC ( ESC / special / hexpair )\n"
843 "special = escaped / SPACE / SHARP / EQUALS\n"
844 "escaped = DQUOTE / PLUS / COMMA / SEMI / LANGLE / RANGLE\n"
845 "hexstring = SHARP 1*hexpair\n"
846 "hexpair = HEX HEX\n",
847 .re_posix = NULL,
848 .re_pcre = NULL,
849 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
850 .spec_type = LDAPSCHEMA_SPEC_RFC,
851 .spec_name = "4517",
852 .spec_section = "3.3.9",
853 .spec_source = NULL,
854 .spec_vendor = "IETF",
855 .examples = (const char *[])
856 {
857 "UID=jsmith,DC=example,DC=net",
858 "OU=Sales+CN=J. Smith,DC=example,DC=net",
859 "CN=James \\\"Jim\\\" Smith\\, III,DC=example,DC=net",
860 "CN=Before\\0dAfter,DC=example,DC=net",
861 NULL,
862 },
863};
864
865
866
867{
868 //
869 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
870 //
871 // 3.3.10. Enhanced Guide
872 //
873 // A value of the Enhanced Guide syntax suggests criteria, which consist
874 // of combinations of attribute types and filter operators, to be used
875 // in constructing filters to search for entries of particular object
876 // classes. The Enhanced Guide syntax improves upon the Guide syntax by
877 // allowing the recommended depth of the search to be specified.
878 //
879 // The LDAP-specific encoding of a value of this syntax is defined by
880 // the following ABNF:
881 //
882 // EnhancedGuide = object-class SHARP WSP criteria WSP
883 // SHARP WSP subset
884 // object-class = WSP oid WSP
885 // subset = "baseobject" / "oneLevel" / "wholeSubtree"
886 //
887 // criteria = and-term *( BAR and-term )
888 // and-term = term *( AMPERSAND term )
889 // term = EXCLAIM term /
890 // attributetype DOLLAR match-type /
891 // LPAREN criteria RPAREN /
892 // true /
893 // false
894 // match-type = "EQ" / "SUBSTR" / "GE" / "LE" / "APPROX"
895 // true = "?true"
896 // false = "?false"
897 // BAR = %x7C ; vertical bar ("|")
898 // AMPERSAND = %x26 ; ampersand ("&")
899 // EXCLAIM = %x21 ; exclamation mark ("!")
900 //
901 // The <SHARP>, <WSP>, <oid>, <LPAREN>, <RPAREN>, <attributetype>, and
902 // <DOLLAR> rules are defined in [RFC4512].
903 //
904 // The LDAP definition for the Enhanced Guide syntax is:
905 //
906 // ( 1.3.6.1.4.1.1466.115.121.1.21 DESC 'Enhanced Guide' )
907 //
908 // Example:
909 // person#(sn$EQ)#oneLevel
910 //
911 // The Enhanced Guide syntax corresponds to the EnhancedGuide ASN.1 type
912 // from [X.520]. The EnhancedGuide type references the Criteria ASN.1
913 // type, also from [X.520]. The <true> rule, above, represents an empty
914 // "and" expression in a value of the Criteria type. The <false> rule,
915 // above, represents an empty "or" expression in a value of the Criteria
916 // type.
917 //
918 .oid = "1.3.6.1.4.1.1466.115.121.1.21",
919 .name = "EnhancedGuide",
920 .desc = "Enhanced Guide",
921 .flags = LDAPSCHEMA_O_READABLE | LDAPSCHEMA_O_COMMON_ABNF,
922 .type = LDAPSCHEMA_SYNTAX,
923 .class = LDAPSCHEMA_CLASS_ASCII,
924 .def = "( 1.3.6.1.4.1.1466.115.121.1.21 DESC 'Enhanced Guide' )",
925 .abnf = "EnhancedGuide = object-class SHARP WSP criteria WSP\n"
926 " SHARP WSP subset\n"
927 "object-class = WSP oid WSP\n"
928 "subset = \"baseobject\" / \"oneLevel\" / \"wholeSubtree\"\n"
929 " \n"
930 "criteria = and-term *( BAR and-term )\n"
931 "and-term = term *( AMPERSAND term )\n"
932 "term = EXCLAIM term /\n"
933 " attributetype DOLLAR match-type /\n"
934 " LPAREN criteria RPAREN /\n"
935 " true /\n"
936 " false \n"
937 "match-type = \"EQ\" / \"SUBSTR\" / \"GE\" / \"LE\" / \"APPROX\"\n"
938 "true = \"?true\"\n"
939 "false = \"?false\"\n"
940 "BAR = %x7C ; vertical bar (\"|\") \n"
941 "AMPERSAND = %x26 ; ampersand (\"&\") \n"
942 "EXCLAIM = %x21 ; exclamation mark (\"!\") \n",
943 .re_posix = NULL,
944 .re_pcre = NULL,
945 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
946 .spec_type = LDAPSCHEMA_SPEC_RFC,
947 .spec_name = "4517",
948 .spec_section = "3.3.10",
949 .spec_source = NULL,
950 .spec_vendor = "IETF",
951 .examples = (const char *[])
952 {
953 "person#(sn$EQ)#oneLevel",
954 NULL,
955 },
956};
957
958
959
960{
961 //
962 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
963 //
964 // 3.3.11. Facsimile Telephone Number
965 //
966 // A value of the Facsimile Telephone Number syntax is a subscriber
967 // number of a facsimile device on the public switched telephone
968 // network. The LDAP-specific encoding of a value of this syntax is
969 // defined by the following ABNF:
970 //
971 // fax-number = telephone-number *( DOLLAR fax-parameter )
972 // telephone-number = PrintableString
973 // fax-parameter = "twoDimensional" /
974 // "fineResolution" /
975 // "unlimitedLength" /
976 // "b4Length" /
977 // "a3Width" /
978 // "b4Width" /
979 // "uncompressed"
980 //
981 // The <telephone-number> is a string of printable characters that
982 // complies with the internationally agreed format for representing
983 // international telephone numbers [E.123]. The <PrintableString> rule
984 // is defined in Section 3.2. The <DOLLAR> rule is defined in
985 // [RFC4512].
986 //
987 // The LDAP definition for the Facsimile Telephone Number syntax is:
988 //
989 // ( 1.3.6.1.4.1.1466.115.121.1.22 DESC 'Facsimile Telephone Number')
990 //
991 // The Facsimile Telephone Number syntax corresponds to the
992 // FacsimileTelephoneNumber ASN.1 type from [X.520].
993 //
994 .oid = "1.3.6.1.4.1.1466.115.121.1.22",
995 .name = "FacsimileTelephoneNumber",
996 .desc = "Facsimile Telephone Number",
997 .flags = LDAPSCHEMA_O_READABLE | LDAPSCHEMA_O_COMMON_ABNF,
998 .type = LDAPSCHEMA_SYNTAX,
999 .class = LDAPSCHEMA_CLASS_ASCII,
1000 .def = "( 1.3.6.1.4.1.1466.115.121.1.22 DESC 'Facsimile Telephone Number')",
1001 .abnf = "fax-number = telephone-number *( DOLLAR fax-parameter )\n"
1002 "telephone-number = PrintableString\n"
1003 "fax-parameter = \"twoDimensional\" /\n"
1004 " \"fineResolution\" /\n"
1005 " \"unlimitedLength\" /\n"
1006 " \"b4Length\" /\n"
1007 " \"a3Width\" /\n"
1008 " \"b4Width\" /\n"
1009 " \"uncompressed\"\n"
1010 "PrintableString = 1*PrintableCharacter\n"
1011 "PrintableCharacter = ALPHA / DIGIT / SQUOTE / LPAREN / RPAREN /\n"
1012 " PLUS / COMMA / HYPHEN / DOT / EQUALS /\n"
1013 " SLASH / COLON / QUESTION / SPACE\n",
1014 .re_posix = NULL,
1015 .re_pcre = NULL,
1016 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
1017 .spec_type = LDAPSCHEMA_SPEC_RFC,
1018 .spec_name = "4517",
1019 .spec_section = "3.3.11",
1020 .spec_source = NULL,
1021 .spec_vendor = "IETF",
1022 .examples = NULL,
1023};
1024
1025
1026
1027{
1028 //
1029 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
1030 //
1031 // 3.3.12. Fax
1032 //
1033 // A value of the Fax syntax is an image that is produced using the
1034 // Group 3 facsimile process [FAX] to duplicate an object, such as a
1035 // memo. The LDAP-specific encoding of a value of this syntax is the
1036 // string of octets for a Group 3 Fax image as defined in [FAX].
1037 //
1038 // The LDAP definition for the Fax syntax is:
1039 //
1040 // ( 1.3.6.1.4.1.1466.115.121.1.23 DESC 'Fax' )
1041 //
1042 // The ASN.1 type corresponding to the Fax syntax is defined as follows,
1043 // assuming EXPLICIT TAGS:
1044 //
1045 // Fax ::= CHOICE {
1046 // g3-facsimile [3] G3FacsimileBodyPart
1047 // }
1048 //
1049 // The G3FacsimileBodyPart ASN.1 type is defined in [X.420].
1050 //
1051 .oid = "1.3.6.1.4.1.1466.115.121.1.23",
1052 .name = "Fax",
1053 .desc = "Fax",
1054 .flags = 0,
1055 .type = LDAPSCHEMA_SYNTAX,
1056 .class = LDAPSCHEMA_CLASS_IMAGE,
1057 .def = "( 1.3.6.1.4.1.1466.115.121.1.23 DESC 'Fax' )",
1058 .abnf = NULL,
1059 .re_posix = NULL,
1060 .re_pcre = NULL,
1061 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
1062 .spec_type = LDAPSCHEMA_SPEC_RFC,
1063 .spec_name = "4517",
1064 .spec_section = "3.3.12",
1065 .spec_source = NULL,
1066 .spec_vendor = "IETF",
1067 .examples = NULL,
1068};
1069
1070
1071
1072{
1073 //
1074 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
1075 //
1076 // 3.3.13. Generalized Time
1077 //
1078 // A value of the Generalized Time syntax is a character string
1079 // representing a date and time. The LDAP-specific encoding of a value
1080 // of this syntax is a restriction of the format defined in [ISO8601],
1081 // and is described by the following ABNF:
1082 //
1083 // GeneralizedTime = century year month day hour
1084 // [ minute [ second / leap-second ] ]
1085 // [ fraction ]
1086 // g-time-zone
1087 //
1088 // century = 2(%x30-39) ; "00" to "99"
1089 // year = 2(%x30-39) ; "00" to "99"
1090 // month = ( %x30 %x31-39 ) ; "01" (January) to "09"
1091 // / ( %x31 %x30-32 ) ; "10" to "12"
1092 // day = ( %x30 %x31-39 ) ; "01" to "09"
1093 // / ( %x31-32 %x30-39 ) ; "10" to "29"
1094 // / ( %x33 %x30-31 ) ; "30" to "31"
1095 // hour = ( %x30-31 %x30-39 ) / ( %x32 %x30-33 ) ; "00" to "23"
1096 // minute = %x30-35 %x30-39 ; "00" to "59"
1097 //
1098 // second = ( %x30-35 %x30-39 ) ; "00" to "59"
1099 // leap-second = ( %x36 %x30 ) ; "60"
1100 //
1101 // fraction = ( DOT / COMMA ) 1*(%x30-39)
1102 // g-time-zone = %x5A ; "Z"
1103 // / g-differential
1104 // g-differential = ( MINUS / PLUS ) hour [ minute ]
1105 // MINUS = %x2D ; minus sign ("-")
1106 //
1107 // The <DOT>, <COMMA>, and <PLUS> rules are defined in [RFC4512].
1108 //
1109 // The above ABNF allows character strings that do not represent valid
1110 // dates (in the Gregorian calendar) and/or valid times (e.g., February
1111 // 31, 1994). Such character strings SHOULD be considered invalid for
1112 // this syntax.
1113 //
1114 // The time value represents coordinated universal time (equivalent to
1115 // Greenwich Mean Time) if the "Z" form of <g-time-zone> is used;
1116 // otherwise, the value represents a local time in the time zone
1117 // indicated by <g-differential>. In the latter case, coordinated
1118 // universal time can be calculated by subtracting the differential from
1119 // the local time. The "Z" form of <g-time-zone> SHOULD be used in
1120 // preference to <g-differential>.
1121 //
1122 // If <minute> is omitted, then <fraction> represents a fraction of an
1123 // hour; otherwise, if <second> and <leap-second> are omitted, then
1124 // <fraction> represents a fraction of a minute; otherwise, <fraction>
1125 // represents a fraction of a second.
1126 //
1127 // Examples:
1128 // 199412161032Z
1129 // 199412160532-0500
1130 //
1131 // Both example values represent the same coordinated universal time:
1132 // 10:32 AM, December 16, 1994.
1133 //
1134 // The LDAP definition for the Generalized Time syntax is:
1135 //
1136 // ( 1.3.6.1.4.1.1466.115.121.1.24 DESC 'Generalized Time' )
1137 //
1138 // This syntax corresponds to the GeneralizedTime ASN.1 type from
1139 // [ASN.1], with the constraint that local time without a differential
1140 // SHALL NOT be used.
1141 //
1142 .oid = "1.3.6.1.4.1.1466.115.121.1.24",
1143 .name = "GeneralizedTime",
1144 .desc = "Generalized Time",
1145 .flags = LDAPSCHEMA_O_READABLE,
1146 .type = LDAPSCHEMA_SYNTAX,
1147 .class = LDAPSCHEMA_CLASS_ASCII,
1148 .def = "( 1.3.6.1.4.1.1466.115.121.1.24 DESC 'Generalized Time' )",
1149 .abnf = "GeneralizedTime = century year month day hour\n"
1150 " [ minute [ second / leap-second ] ]\n"
1151 " [ fraction ]\n"
1152 " g-time-zone\n"
1153 "\n"
1154 "century = 2(%x30-39) ; \"00\" to \"99\"\n"
1155 "year = 2(%x30-39) ; \"00\" to \"99\"\n"
1156 "month = ( %x30 %x31-39 ) ; \"01\" (January) to \"09\"\n"
1157 " / ( %x31 %x30-32 ) ; \"10\" to \"12\"\n"
1158 "day = ( %x30 %x31-39 ) ; \"01\" to \"09\"\n"
1159 " / ( %x31-32 %x30-39 ) ; \"10\" to \"29\"\n"
1160 " / ( %x33 %x30-31 ) ; \"30\" to \"31\"\n"
1161 "hour = ( %x30-31 %x30-39 ) / ( %x32 %x30-33 ) ; \"00\" to \"23\"\n"
1162 "minute = %x30-35 %x30-39 ; \"00\" to \"59\"\n"
1163 "\n"
1164 "second = ( %x30-35 %x30-39 ) ; \"00\" to \"59\"\n"
1165 "leap-second = ( %x36 %x30 ) ; \"60\"\n"
1166 "\n"
1167 "fraction = ( DOT / COMMA ) 1*(%x30-39)\n"
1168 "g-time-zone = %x5A ; \"Z\" \n"
1169 " / g-differential\n"
1170 "g-differential = ( MINUS / PLUS ) hour [ minute ]\n"
1171 "MINUS = %x2D ; minus sign (\"-\") \n"
1172 "DOT = %x2E ; period (\".\")\n"
1173 "COMMA = %x2C ; comma (\",\")\n"
1174 "PLUS = %x2B ; plus sign (\"+\")\n",
1175 .re_posix = NULL,
1176 .re_pcre = NULL,
1177 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
1178 .spec_type = LDAPSCHEMA_SPEC_RFC,
1179 .spec_name = "4517",
1180 .spec_section = "3.3.13",
1181 .spec_source = NULL,
1182 .spec_vendor = "IETF",
1183 .examples = (const char *[])
1184 {
1185 "199412161032Z",
1186 "199412160532-0500",
1187 NULL,
1188 },
1189};
1190
1191
1192
1193{
1194 //
1195 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
1196 //
1197 // 3.3.14. Guide
1198 //
1199 // A value of the Guide syntax suggests criteria, which consist of
1200 // combinations of attribute types and filter operators, to be used in
1201 // constructing filters to search for entries of particular object
1202 // classes. The Guide syntax is obsolete and should not be used for
1203 // defining new attribute types.
1204 //
1205 // The LDAP-specific encoding of a value of this syntax is defined by
1206 // the following ABNF:
1207 //
1208 // Guide = [ object-class SHARP ] criteria
1209 //
1210 // The <object-class> and <criteria> rules are defined in Section
1211 // 3.3.10. The <SHARP> rule is defined in [RFC4512].
1212 //
1213 // The LDAP definition for the Guide syntax is:
1214 //
1215 // ( 1.3.6.1.4.1.1466.115.121.1.25 DESC 'Guide' )
1216 //
1217 // The Guide syntax corresponds to the Guide ASN.1 type from [X.520].
1218 //
1219 .oid = "1.3.6.1.4.1.1466.115.121.1.25",
1220 .name = "Guide",
1221 .desc = "Guide",
1222 .flags = LDAPSCHEMA_O_READABLE | LDAPSCHEMA_O_COMMON_ABNF,
1223 .type = LDAPSCHEMA_SYNTAX,
1224 .class = LDAPSCHEMA_CLASS_ASCII,
1225 .def = "( 1.3.6.1.4.1.1466.115.121.1.25 DESC 'Guide' )",
1226 .abnf = "Guide = [ object-class SHARP ] criteria\n"
1227 "object-class = WSP oid WSP\n"
1228 "criteria = and-term *( BAR and-term )\n"
1229 "and-term = term *( AMPERSAND term )\n"
1230 "term = EXCLAIM term /\n"
1231 " attributetype DOLLAR match-type /\n"
1232 " LPAREN criteria RPAREN /\n"
1233 " true /\n"
1234 " false\n"
1235 "match-type = \"EQ\" / \"SUBSTR\" / \"GE\" / \"LE\" / \"APPROX\"\n"
1236 "true = \"?true\"\n"
1237 "false = \"?false\"\n"
1238 "BAR = %x7C ; vertical bar (\"|\")\n"
1239 "AMPERSAND = %x26 ; ampersand (\"&\")\n"
1240 "EXCLAIM = %x21 ; exclamation mark (\"!\")\n",
1241 .re_posix = NULL,
1242 .re_pcre = NULL,
1243 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
1244 .spec_type = LDAPSCHEMA_SPEC_RFC,
1245 .spec_name = "4517",
1246 .spec_section = "3.3.14",
1247 .spec_source = NULL,
1248 .spec_vendor = "IETF",
1249 .examples = NULL,
1250};
1251
1252
1253
1254{
1255 //
1256 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
1257 //
1258 // 3.3.15. IA5 String
1259 //
1260 // A value of the IA5 String syntax is a string of zero, one, or more
1261 // characters from International Alphabet 5 (IA5) [T.50], the
1262 // international version of the ASCII character set. The LDAP-specific
1263 // encoding of a value of this syntax is the unconverted string of
1264 // characters, which conforms to the <IA5String> rule in Section 3.2.
1265 //
1266 // The LDAP definition for the IA5 String syntax is:
1267 //
1268 // ( 1.3.6.1.4.1.1466.115.121.1.26 DESC 'IA5 String' )
1269 //
1270 // This syntax corresponds to the IA5String ASN.1 type from [ASN.1].
1271 //
1272 .oid = "1.3.6.1.4.1.1466.115.121.1.26",
1273 .name = "IA5String",
1274 .desc = "IA5 String",
1275 .flags = LDAPSCHEMA_O_READABLE | LDAPSCHEMA_O_COMMON_ABNF,
1276 .type = LDAPSCHEMA_SYNTAX,
1277 .class = LDAPSCHEMA_CLASS_ASCII,
1278 .def = "( 1.3.6.1.4.1.1466.115.121.1.26 DESC 'IA5 String' )",
1279 .abnf = "IA5String = *(%x00-7F)",
1280 .re_posix = NULL,
1281 .re_pcre = NULL,
1282 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
1283 .spec_type = LDAPSCHEMA_SPEC_RFC,
1284 .spec_name = "4517",
1285 .spec_section = "3.3.15",
1286 .spec_source = NULL,
1287 .spec_vendor = "IETF",
1288 .examples = NULL,
1289};
1290
1291
1292
1293{
1294 //
1295 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
1296 //
1297 // 3.3.16. Integer
1298 //
1299 // A value of the Integer syntax is a whole number of unlimited
1300 // magnitude. The LDAP-specific encoding of a value of this syntax is
1301 // the optionally signed decimal digit character string representation
1302 // of the number (for example, the number 1321 is represented by the
1303 // character string "1321"). The encoding is defined by the following
1304 // ABNF:
1305 //
1306 // Integer = ( HYPHEN LDIGIT *DIGIT ) / number
1307 //
1308 // The <HYPHEN>, <LDIGIT>, <DIGIT>, and <number> rules are defined in
1309 // [RFC4512].
1310 //
1311 // The LDAP definition for the Integer syntax is:
1312 //
1313 // ( 1.3.6.1.4.1.1466.115.121.1.27 DESC 'INTEGER' )
1314 //
1315 // This syntax corresponds to the INTEGER ASN.1 type from [ASN.1].
1316 //
1317 .oid = "1.3.6.1.4.1.1466.115.121.1.27",
1318 .name = "Integer",
1319 .desc = "Integer",
1320 .flags = LDAPSCHEMA_O_READABLE,
1321 .type = LDAPSCHEMA_SYNTAX,
1322 .class = LDAPSCHEMA_CLASS_ASCII,
1323 .def = "( 1.3.6.1.4.1.1466.115.121.1.27 DESC 'INTEGER' )",
1324 .abnf = "Integer = ( HYPHEN LDIGIT *DIGIT ) / number\n"
1325 "number = DIGIT / ( LDIGIT 1*DIGIT )\n"
1326 "HYPHEN = %x2D ; hyphen (\"-\")\n"
1327 "DIGIT = %x30 / LDIGIT ; \"0\"-\"9\"\n"
1328 "LDIGIT = %x31-39 ; \"1\"-\"9\"\n",
1329 .re_posix = "^(-[1-9][0-9]{0,}|[0-9]{1,})$",
1330 .re_pcre = "^(-[1-9][0-9]{0,}|[0-9]{1,})$",
1331 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
1332 .spec_type = LDAPSCHEMA_SPEC_RFC,
1333 .spec_name = "4517",
1334 .spec_section = "3.3.16",
1335 .spec_source = NULL,
1336 .spec_vendor = "IETF",
1337 .examples = NULL,
1338};
1339
1340
1341
1342{
1343 //
1344 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
1345 //
1346 // 3.3.17. JPEG
1347 //
1348 // A value of the JPEG syntax is an image in the JPEG File Interchange
1349 // Format (JFIF), as described in [JPEG]. The LDAP-specific encoding of
1350 // a value of this syntax is the sequence of octets of the JFIF encoding
1351 // of the image.
1352 //
1353 // The LDAP definition for the JPEG syntax is:
1354 //
1355 // ( 1.3.6.1.4.1.1466.115.121.1.28 DESC 'JPEG' )
1356 //
1357 // The JPEG syntax corresponds to the following ASN.1 type:
1358 //
1359 // JPEG ::= OCTET STRING (CONSTRAINED BY
1360 // { -- contents octets are an image in the --
1361 // -- JPEG File Interchange Format -- })
1362 //
1363 .oid = "1.3.6.1.4.1.1466.115.121.1.28",
1364 .name = "JPEG",
1365 .desc = "JPEG",
1366 .flags = 0,
1367 .type = LDAPSCHEMA_SYNTAX,
1368 .class = LDAPSCHEMA_CLASS_IMAGE,
1369 .def = "( 1.3.6.1.4.1.1466.115.121.1.28 DESC 'JPEG' )",
1370 .abnf = NULL,
1371 .re_posix = NULL,
1372 .re_pcre = NULL,
1373 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
1374 .spec_type = LDAPSCHEMA_SPEC_RFC,
1375 .spec_name = "4517",
1376 .spec_section = "3.3.17",
1377 .spec_source = NULL,
1378 .spec_vendor = "IETF",
1379 .examples = NULL,
1380};
1381
1382
1383
1384{
1385 //
1386 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
1387 //
1388 // 3.3.18. LDAP Syntax Description
1389 //
1390 // A value of the LDAP Syntax Description syntax is the description of
1391 // an LDAP syntax. The LDAP-specific encoding of a value of this syntax
1392 // is defined by the <SyntaxDescription> rule in [RFC4512].
1393 //
1394 // The LDAP definition for the LDAP Syntax Description syntax is:
1395 //
1396 // ( 1.3.6.1.4.1.1466.115.121.1.54 DESC 'LDAP Syntax Description' )
1397 //
1398 // The above LDAP definition for the LDAP Syntax Description syntax is
1399 // itself a legal value of the LDAP Syntax Description syntax.
1400 //
1401 // The ASN.1 type corresponding to the LDAP Syntax Description syntax is
1402 // defined as follows, assuming EXPLICIT TAGS:
1403 //
1404 // LDAPSyntaxDescription ::= SEQUENCE {
1405 // identifier OBJECT IDENTIFIER,
1406 // description DirectoryString { ub-schema } OPTIONAL }
1407 //
1408 // The DirectoryString parameterized ASN.1 type is defined in [X.520].
1409 //
1410 // The value of ub-schema (an integer) is implementation defined. A
1411 // non-normative definition appears in [X.520].
1412 //
1413 .oid = "1.3.6.1.4.1.1466.115.121.1.54",
1414 .name = "SyntaxDescription",
1415 .desc = "LDAP Syntax Description",
1416 .flags = LDAPSCHEMA_O_READABLE,
1417 .type = LDAPSCHEMA_SYNTAX,
1418 .class = LDAPSCHEMA_CLASS_ASCII,
1419 .def = "( 1.3.6.1.4.1.1466.115.121.1.54 DESC 'LDAP Syntax Description' )",
1420 .abnf = NULL,
1421 .re_posix = NULL,
1422 .re_pcre = NULL,
1423 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
1424 .spec_type = LDAPSCHEMA_SPEC_RFC,
1425 .spec_name = "4517",
1426 .spec_section = "3.3.18",
1427 .spec_source = NULL,
1428 .spec_vendor = "IETF",
1429 .examples = NULL,
1430};
1431
1432
1433
1434{
1435 //
1436 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
1437 //
1438 // 3.3.19. Matching Rule Description
1439 //
1440 // A value of the Matching Rule Description syntax is the definition of
1441 // a matching rule. The LDAP-specific encoding of a value of this
1442 // syntax is defined by the <MatchingRuleDescription> rule in [RFC4512].
1443 //
1444 // Example:
1445 // ( 2.5.13.2 NAME 'caseIgnoreMatch'
1446 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )
1447 //
1448 // Note: A line break has been added for readability; it is not part of
1449 // the syntax.
1450 //
1451 // The LDAP definition for the Matching Rule Description syntax is:
1452 //
1453 // ( 1.3.6.1.4.1.1466.115.121.1.30 DESC 'Matching Rule Description' )
1454 //
1455 // This syntax corresponds to the MatchingRuleDescription ASN.1 type
1456 // from [X.501].
1457 //
1458 .oid = "1.3.6.1.4.1.1466.115.121.1.30",
1459 .name = "MatchingRuleDescription",
1460 .desc = "Matching Rule Description",
1461 .flags = LDAPSCHEMA_O_READABLE,
1462 .type = LDAPSCHEMA_SYNTAX,
1463 .class = LDAPSCHEMA_CLASS_ASCII,
1464 .def = "( 1.3.6.1.4.1.1466.115.121.1.30 DESC 'Matching Rule Description' )",
1465 .abnf = NULL,
1466 .re_posix = NULL,
1467 .re_pcre = NULL,
1468 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
1469 .spec_type = LDAPSCHEMA_SPEC_RFC,
1470 .spec_name = "4517",
1471 .spec_section = "3.3.19",
1472 .spec_source = NULL,
1473 .spec_vendor = "IETF",
1474 .examples = NULL,
1475};
1476
1477
1478
1479{
1480 //
1481 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
1482 //
1483 // 3.3.20. Matching Rule Use Description
1484 //
1485 // A value of the Matching Rule Use Description syntax indicates the
1486 // attribute types to which a matching rule may be applied in an
1487 // extensibleMatch search filter [RFC4511]. The LDAP-specific encoding
1488 // of a value of this syntax is defined by the
1489 // <MatchingRuleUseDescription> rule in [RFC4512].
1490 //
1491 // Example:
1492 // ( 2.5.13.16 APPLIES ( givenName $ surname ) )
1493 //
1494 // The LDAP definition for the Matching Rule Use Description syntax is:
1495 //
1496 // ( 1.3.6.1.4.1.1466.115.121.1.31
1497 // DESC 'Matching Rule Use Description' )
1498 //
1499 // This syntax corresponds to the MatchingRuleUseDescription ASN.1 type
1500 // from [X.501].
1501 //
1502 .oid = "1.3.6.1.4.1.1466.115.121.1.31",
1503 .name = "MatchingRuleUseDescription",
1504 .desc = "Matching Rule Use Description",
1505 .flags = LDAPSCHEMA_O_READABLE,
1506 .type = LDAPSCHEMA_SYNTAX,
1507 .class = LDAPSCHEMA_CLASS_ASCII,
1508 .def = "( 1.3.6.1.4.1.1466.115.121.1.31 DESC 'Matching Rule Use Description' )",
1509 .abnf = NULL,
1510 .re_posix = NULL,
1511 .re_pcre = NULL,
1512 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
1513 .spec_type = LDAPSCHEMA_SPEC_RFC,
1514 .spec_name = "4517",
1515 .spec_section = "3.3.20",
1516 .spec_source = NULL,
1517 .spec_vendor = "IETF",
1518 .examples = NULL,
1519};
1520
1521
1522
1523{
1524 //
1525 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
1526 //
1527 // 3.3.21. Name and Optional UID
1528 //
1529 // A value of the Name and Optional UID syntax is the distinguished name
1530 // [RFC4512] of an entity optionally accompanied by a unique identifier
1531 // that serves to differentiate the entity from others with an identical
1532 // distinguished name.
1533 //
1534 // The LDAP-specific encoding of a value of this syntax is defined by
1535 // the following ABNF:
1536 //
1537 // NameAndOptionalUID = distinguishedName [ SHARP BitString ]
1538 //
1539 // The <BitString> rule is defined in Section 3.3.2. The
1540 // <distinguishedName> rule is defined in [RFC4514]. The <SHARP> rule
1541 // is defined in [RFC4512].
1542 //
1543 // Note that although the '#' character may occur in the string
1544 // representation of a distinguished name, no additional escaping of
1545 // this character is performed when a <distinguishedName> is encoded in
1546 // a <NameAndOptionalUID>.
1547 //
1548 // Example:
1549 // 1.3.6.1.4.1.1466.0=#04024869,O=Test,C=GB#'0101'B
1550 //
1551 // The LDAP definition for the Name and Optional UID syntax is:
1552 //
1553 // ( 1.3.6.1.4.1.1466.115.121.1.34 DESC 'Name And Optional UID' )
1554 //
1555 // This syntax corresponds to the NameAndOptionalUID ASN.1 type from
1556 // [X.520].
1557 //
1558 .oid = "1.3.6.1.4.1.1466.115.121.1.34",
1559 .name = "NameAndOptionalUID",
1560 .desc = "Name and Optional UID",
1561 .flags = LDAPSCHEMA_O_READABLE,
1562 .type = LDAPSCHEMA_SYNTAX,
1563 .class = LDAPSCHEMA_CLASS_ASCII,
1564 .def = "( 1.3.6.1.4.1.1466.115.121.1.34 DESC 'Name And Optional UID' )",
1565 .abnf = "NameAndOptionalUID = distinguishedName [ SHARP BitString ]",
1566 .re_posix = NULL,
1567 .re_pcre = NULL,
1568 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
1569 .spec_type = LDAPSCHEMA_SPEC_RFC,
1570 .spec_name = "4517",
1571 .spec_section = "3.3.21",
1572 .spec_source = NULL,
1573 .spec_vendor = "IETF",
1574 .examples = NULL,
1575};
1576
1577
1578
1579{
1580 //
1581 // RFC 4512 LDAP Models June 2006
1582 //
1583 // 4.1.7.2. Name Forms
1584 //
1585 // A name form "specifies a permissible RDN for entries of a particular
1586 // structural object class. A name form identifies a named object class
1587 // and one or more attribute types to be used for naming (i.e., for the
1588 // RDN). Name forms are primitive pieces of specification used in the
1589 // definition of DIT structure rules" [X.501].
1590 //
1591 // Each name form indicates the structural object class to be named, a
1592 // set of required attribute types, and a set of allowed attribute
1593 // types. A particular attribute type cannot be in both sets.
1594 //
1595 // Entries governed by the form must be named using a value from each
1596 // required attribute type and zero or more values from the allowed
1597 // attribute types.
1598 //
1599 // Each name form is identified by an object identifier (OID) and,
1600 // optionally, one or more short names (descriptors).
1601 //
1602 // Name form descriptions are written according to the ABNF:
1603 //
1604 // NameFormDescription = LPAREN WSP
1605 // numericoid ; object identifier
1606 // [ SP "NAME" SP qdescrs ] ; short names (descriptors)
1607 // [ SP "DESC" SP qdstring ] ; description
1608 // [ SP "OBSOLETE" ] ; not active
1609 // SP "OC" SP oid ; structural object class
1610 // SP "MUST" SP oids ; attribute types
1611 // [ SP "MAY" SP oids ] ; attribute types
1612 // extensions WSP RPAREN ; extensions
1613 //
1614 // where:
1615 // <numericoid> is object identifier that identifies this name form;
1616 // NAME <qdescrs> are short names (descriptors) identifying this name
1617 // form;
1618 // DESC <qdstring> is a short descriptive string;
1619 // OBSOLETE indicates this name form is not active;
1620 // OC identifies the structural object class this rule applies to,
1621 // MUST and MAY specify the sets of required and allowed,
1622 // respectively, naming attributes for this name form; and
1623 // <extensions> describe extensions.
1624 //
1625 // All attribute types in the required ("MUST") and allowed ("MAY")
1626 // lists shall be different.
1627 //
1628 //
1629 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
1630 //
1631 // 3.3.22. Name Form Description
1632 //
1633 // A value of the Name Form Description syntax is the definition of a
1634 // name form, which regulates how entries may be named. The LDAP-
1635 // specific encoding of a value of this syntax is defined by the
1636 // <NameFormDescription> rule in [RFC4512].
1637 //
1638 // Example:
1639 // ( 2.5.15.3 NAME 'orgNameForm' OC organization MUST o )
1640 //
1641 // The LDAP definition for the Name Form Description syntax is:
1642 //
1643 // ( 1.3.6.1.4.1.1466.115.121.1.35 DESC 'Name Form Description' )
1644 //
1645 // This syntax corresponds to the NameFormDescription ASN.1 type from
1646 // [X.501].
1647 .oid = "1.3.6.1.4.1.1466.115.121.1.35",
1648 .name = "NameFormDescription",
1649 .desc = "Name Form Description",
1650 .flags = LDAPSCHEMA_O_READABLE,
1651 .type = LDAPSCHEMA_SYNTAX,
1652 .class = LDAPSCHEMA_CLASS_ASCII,
1653 .def = "( 1.3.6.1.4.1.1466.115.121.1.35 DESC 'Name Form Description' )",
1654 .abnf = "NameFormDescription = LPAREN WSP\n"
1655 " numericoid ; object identifier\n"
1656 " [ SP \"NAME\" SP qdescrs ] ; short names (descriptors)\n"
1657 " [ SP \"DESC\" SP qdstring ] ; description\n"
1658 " [ SP \"OBSOLETE\" ] ; not active\n"
1659 " SP \"OC\" SP oid ; structural object class \n"
1660 " SP \"MUST\" SP oids ; attribute types \n"
1661 " [ SP \"MAY\" SP oids ] ; attribute types \n"
1662 " extensions WSP RPAREN ; extensions\n",
1663 .re_posix = NULL,
1664 .re_pcre = NULL,
1665 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
1666 .spec_type = LDAPSCHEMA_SPEC_RFC,
1667 .spec_name = "4517",
1668 .spec_section = "3.3.22",
1669 .spec_source = NULL,
1670 .spec_vendor = "IETF",
1671 .examples = (const char *[])
1672 {
1673 "( 2.5.15.3 NAME 'orgNameForm' OC organization MUST o )",
1674 NULL,
1675 },
1676};
1677
1678
1679
1680{
1681 //
1682 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
1683 //
1684 // 3.3.23. Numeric String
1685 //
1686 // A value of the Numeric String syntax is a sequence of one or more
1687 // numerals and spaces. The LDAP-specific encoding of a value of this
1688 // syntax is the unconverted string of characters, which conforms to the
1689 // following ABNF:
1690 //
1691 // NumericString = 1*(DIGIT / SPACE)
1692 //
1693 // The <DIGIT> and <SPACE> rules are defined in [RFC4512].
1694 //
1695 // Example:
1696 // 15 079 672 281
1697 //
1698 // The LDAP definition for the Numeric String syntax is:
1699 //
1700 // ( 1.3.6.1.4.1.1466.115.121.1.36 DESC 'Numeric String' )
1701 //
1702 // This syntax corresponds to the NumericString ASN.1 type from [ASN.1].
1703 //
1704 .oid = "1.3.6.1.4.1.1466.115.121.1.36",
1705 .name = "NumericString",
1706 .desc = "Numeric String",
1707 .flags = LDAPSCHEMA_O_READABLE,
1708 .type = LDAPSCHEMA_SYNTAX,
1709 .class = LDAPSCHEMA_CLASS_ASCII,
1710 .def = "( 1.3.6.1.4.1.1466.115.121.1.36 DESC 'Numeric String' )",
1711 .abnf = "NumericString = 1*(DIGIT / SPACE)\n"
1712 "DIGIT = %x30 / LDIGIT ; \"0\"-\"9\"\n"
1713 "LDIGIT = %x31-39 ; \"1\"-\"9\"\n"
1714 "SPACE = %x20 ; space (\" \")\n",
1715 .re_posix = "^([ 0-9]+)$",
1716 .re_pcre = "^([ 0-9]+)$",
1717 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
1718 .spec_type = LDAPSCHEMA_SPEC_RFC,
1719 .spec_name = "4517",
1720 .spec_section = "3.3.23",
1721 .spec_source = NULL,
1722 .spec_vendor = "IETF",
1723 .examples = (const char *[])
1724 {
1725 "15 079 672 281",
1726 NULL,
1727 },
1728};
1729
1730
1731
1732{
1733 //
1734 // RFC 4512 LDAP Models June 2006
1735 //
1736 // 4.1.1. Object Class Definitions
1737 //
1738 // Object Class definitions are written according to the ABNF:
1739 //
1740 // ObjectClassDescription = LPAREN WSP
1741 // numericoid ; object identifier
1742 // [ SP "NAME" SP qdescrs ] ; short names (descriptors)
1743 // [ SP "DESC" SP qdstring ] ; description
1744 // [ SP "OBSOLETE" ] ; not active
1745 // [ SP "SUP" SP oids ] ; superior object classes
1746 // [ SP kind ] ; kind of class
1747 // [ SP "MUST" SP oids ] ; attribute types
1748 // [ SP "MAY" SP oids ] ; attribute types
1749 // extensions WSP RPAREN
1750 //
1751 // kind = "ABSTRACT" / "STRUCTURAL" / "AUXILIARY"
1752 //
1753 // where:
1754 // <numericoid> is object identifier assigned to this object class;
1755 // NAME <qdescrs> are short names (descriptors) identifying this
1756 // object class;
1757 // DESC <qdstring> is a short descriptive string;
1758 // OBSOLETE indicates this object class is not active;
1759 // SUP <oids> specifies the direct superclasses of this object class;
1760 // the kind of object class is indicated by one of ABSTRACT,
1761 // STRUCTURAL, or AUXILIARY (the default is STRUCTURAL);
1762 // MUST and MAY specify the sets of required and allowed attribute
1763 // types, respectively; and
1764 // <extensions> describe extensions.
1765 //
1766 //
1767 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
1768 //
1769 // 3.3.24. Object Class Description
1770 //
1771 // A value of the Object Class Description syntax is the definition of
1772 // an object class. The LDAP-specific encoding of a value of this
1773 // syntax is defined by the <ObjectClassDescription> rule in [RFC4512].
1774 //
1775 // Example:
1776 // ( 2.5.6.2 NAME 'country' SUP top STRUCTURAL MUST c
1777 // MAY ( searchGuide $ description ) )
1778 //
1779 // Note: A line break has been added for readability; it is not part of
1780 // the syntax.
1781 //
1782 // The LDAP definition for the Object Class Description syntax is:
1783 //
1784 // ( 1.3.6.1.4.1.1466.115.121.1.37 DESC 'Object Class Description' )
1785 //
1786 // This syntax corresponds to the ObjectClassDescription ASN.1 type from
1787 // [X.501].
1788 //
1789 //
1790 .oid = "1.3.6.1.4.1.1466.115.121.1.37",
1791 .name = "ObjectClassDescription",
1792 .desc = "Object Class Description",
1793 .flags = LDAPSCHEMA_O_READABLE | LDAPSCHEMA_O_COMMON_ABNF | LDAPSCHEMA_O_SCHEMA_ABNF,
1794 .type = LDAPSCHEMA_SYNTAX,
1795 .class = LDAPSCHEMA_CLASS_ASCII,
1796 .def = "( 1.3.6.1.4.1.1466.115.121.1.37 DESC 'Object Class Description' )",
1797 .abnf = "ObjectClassDescription = LPAREN WSP\n"
1798 " numericoid ; object identifier\n"
1799 " [ SP \"NAME\" SP qdescrs ] ; short names (descriptors)\n"
1800 " [ SP \"DESC\" SP qdstring ] ; description\n"
1801 " [ SP \"OBSOLETE\" ] ; not active\n"
1802 " [ SP \"SUP\" SP oids ] ; superior object classes\n"
1803 " [ SP kind ] ; kind of class \n"
1804 " [ SP \"MUST\" SP oids ] ; attribute types \n"
1805 " [ SP \"MAY\" SP oids ] ; attribute types \n"
1806 " extensions WSP RPAREN\n"
1807 "\n"
1808 "kind = \"ABSTRACT\" / \"STRUCTURAL\" / \"AUXILIARY\"\n",
1809 .re_posix = NULL,
1810 .re_pcre = NULL,
1811 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
1812 .spec_type = LDAPSCHEMA_SPEC_RFC,
1813 .spec_name = "4517",
1814 .spec_section = "3.3.24",
1815 .spec_source = NULL,
1816 .spec_vendor = "IETF",
1817 .examples = (const char *[])
1818 {
1819 "( 2.5.6.2 NAME 'country' SUP top STRUCTURAL MUST c MAY ( searchGuide $ description ) )",
1820 NULL,
1821 },
1822};
1823
1824
1825
1826{
1827 //
1828 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
1829 //
1830 // 3.3.25. Octet String
1831 //
1832 // A value of the Octet String syntax is a sequence of zero, one, or
1833 // more arbitrary octets. The LDAP-specific encoding of a value of this
1834 // syntax is the unconverted sequence of octets, which conforms to the
1835 // following ABNF:
1836 //
1837 // OctetString = *OCTET
1838 //
1839 // The <OCTET> rule is defined in [RFC4512]. Values of this syntax are
1840 // not generally human-readable.
1841 //
1842 // The LDAP definition for the Octet String syntax is:
1843 //
1844 // ( 1.3.6.1.4.1.1466.115.121.1.40 DESC 'Octet String' )
1845 //
1846 // This syntax corresponds to the OCTET STRING ASN.1 type from [ASN.1].
1847 //
1848 .oid = "1.3.6.1.4.1.1466.115.121.1.40",
1849 .name = "OctetString",
1850 .desc = "Octet String",
1851 .flags = LDAPSCHEMA_O_READABLE,
1852 .type = LDAPSCHEMA_SYNTAX,
1853 .class = LDAPSCHEMA_CLASS_ASCII,
1854 .def = "( 1.3.6.1.4.1.1466.115.121.1.40 DESC 'Octet String' )",
1855 .abnf = "OctetString = *OCTET\n"
1856 "OCTET = %x00-FF ; Any octet (8-bit data unit)\n",
1857 .re_posix = NULL,
1858 .re_pcre = NULL,
1859 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
1860 .spec_type = LDAPSCHEMA_SPEC_RFC,
1861 .spec_name = "4517",
1862 .spec_section = "3.3.25",
1863 .spec_source = NULL,
1864 .spec_vendor = "IETF",
1865 .examples = NULL,
1866};
1867
1868
1869
1870{
1871 //
1872 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
1873 //
1874 // 3.3.26. OID
1875 //
1876 // A value of the OID syntax is an object identifier: a sequence of two
1877 // or more non-negative integers that uniquely identify some object or
1878 // item of specification. Many of the object identifiers used in LDAP
1879 // also have IANA registered names [RFC4520].
1880 //
1881 // The LDAP-specific encoding of a value of this syntax is defined by
1882 // the <oid> rule in [RFC4512].
1883 //
1884 // Examples:
1885 // 1.2.3.4
1886 // cn
1887 //
1888 // The LDAP definition for the OID syntax is:
1889 //
1890 // ( 1.3.6.1.4.1.1466.115.121.1.38 DESC 'OID' )
1891 //
1892 // This syntax corresponds to the OBJECT IDENTIFIER ASN.1 type from
1893 // [ASN.1].
1894 //
1895 .oid = "1.3.6.1.4.1.1466.115.121.1.38",
1896 .name = "OID",
1897 .desc = "OID",
1898 .flags = LDAPSCHEMA_O_READABLE,
1899 .type = LDAPSCHEMA_SYNTAX,
1900 .class = LDAPSCHEMA_CLASS_ASCII,
1901 .def = "( 1.3.6.1.4.1.1466.115.121.1.38 DESC 'OID' )",
1902 .abnf = "oid = descr / numericoid\n"
1903 "\n"
1904 "descr = keystring\n"
1905 "keystring = leadkeychar *keychar\n"
1906 "leadkeychar = ALPHA\n"
1907 "keychar = ALPHA / DIGIT / HYPHEN\n"
1908 "\n"
1909 "numericoid = number 1*( DOT number )\n"
1910 "number = DIGIT / ( LDIGIT 1*DIGIT )\n"
1911 "\n"
1912 "ALPHA = %x41-5A / %x61-7A ; \"A\"-\"Z\" / \"a\"-\"z\"\n"
1913 "DIGIT = %x30 / LDIGIT ; \"0\"-\"9\"\n"
1914 "LDIGIT = %x31-39 ; \"1\"-\"9\"\n"
1915 "DOT = %x2E ; period (\".\")\n"
1916 "HYPHEN = %x2D ; hyphen (\"-\")\n",
1917 .re_posix = NULL,
1918 .re_pcre = NULL,
1919 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
1920 .spec_type = LDAPSCHEMA_SPEC_RFC,
1921 .spec_name = "4517",
1922 .spec_section = "3.3.26",
1923 .spec_source = NULL,
1924 .spec_vendor = "IETF",
1925 .examples = (const char *[])
1926 {
1927 "1.2.3.4",
1928 "cn",
1929 NULL,
1930 },
1931};
1932
1933
1934
1935{
1936 //
1937 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
1938 //
1939 // 3.3.27. Other Mailbox
1940 //
1941 // A value of the Other Mailbox syntax identifies an electronic mailbox,
1942 // in a particular named mail system. The LDAP-specific encoding of a
1943 // value of this syntax is defined by the following ABNF:
1944 //
1945 // OtherMailbox = mailbox-type DOLLAR mailbox
1946 // mailbox-type = PrintableString
1947 // mailbox = IA5String
1948 //
1949 // The <mailbox-type> rule represents the type of mail system in which
1950 // the mailbox resides (for example, "MCIMail"), and <mailbox> is the
1951 // actual mailbox in the mail system described by <mailbox-type>. The
1952 // <PrintableString> and <IA5String> rules are defined in Section 3.2.
1953 // The <DOLLAR> rule is defined in [RFC4512].
1954 //
1955 // The LDAP definition for the Other Mailbox syntax is:
1956 //
1957 // ( 1.3.6.1.4.1.1466.115.121.1.39 DESC 'Other Mailbox' )
1958 //
1959 // The ASN.1 type corresponding to the Other Mailbox syntax is defined
1960 // as follows, assuming EXPLICIT TAGS:
1961 //
1962 // OtherMailbox ::= SEQUENCE {
1963 // mailboxType PrintableString,
1964 // mailbox IA5String
1965 // }
1966 //
1967 .oid = "1.3.6.1.4.1.1466.115.121.1.39",
1968 .name = "OtherMailbox",
1969 .desc = "Other Mailbox",
1970 .flags = LDAPSCHEMA_O_READABLE | LDAPSCHEMA_O_COMMON_ABNF,
1971 .type = LDAPSCHEMA_SYNTAX,
1972 .class = LDAPSCHEMA_CLASS_ASCII,
1973 .def = "( 1.3.6.1.4.1.1466.115.121.1.39 DESC 'Other Mailbox' )",
1974 .abnf = "OtherMailbox = mailbox-type DOLLAR mailbox\n"
1975 "mailbox-type = PrintableString\n"
1976 "mailbox = IA5String\n",
1977 .re_posix = NULL,
1978 .re_pcre = NULL,
1979 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
1980 .spec_type = LDAPSCHEMA_SPEC_RFC,
1981 .spec_name = "4517",
1982 .spec_section = "3.3.27",
1983 .spec_source = NULL,
1984 .spec_vendor = "IETF",
1985 .examples = NULL,
1986};
1987
1988
1989
1990{
1991 //
1992 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
1993 //
1994 // 3.3.28. Postal Address
1995 //
1996 // A value of the Postal Address syntax is a sequence of strings of one
1997 // or more arbitrary UCS characters, which form an address in a physical
1998 // mail system.
1999 //
2000 // The LDAP-specific encoding of a value of this syntax is defined by
2001 // the following ABNF:
2002 //
2003 // PostalAddress = line *( DOLLAR line )
2004 // line = 1*line-char
2005 // line-char = %x00-23
2006 // / (%x5C "24") ; escaped "$"
2007 // / %x25-5B
2008 // / (%x5C "5C") ; escaped "\"
2009 // / %x5D-7F
2010 // / UTFMB
2011 //
2012 // Each character string (i.e., <line>) of a postal address value is
2013 // encoded as a UTF-8 [RFC3629] string, except that "\" and "$"
2014 // characters, if they occur in the string, are escaped by a "\"
2015 // character followed by the two hexadecimal digit code for the
2016 // character. The <DOLLAR> and <UTFMB> rules are defined in [RFC4512].
2017 //
2018 // Many servers limit the postal address to no more than six lines of no
2019 // more than thirty characters each.
2020 //
2021 // Example:
2022 // 1234 Main St.$Anytown, CA 12345$USA
2023 // \241,000,000 Sweepstakes$PO Box 1000000$Anytown, CA 12345$USA
2024 //
2025 // The LDAP definition for the Postal Address syntax is:
2026 //
2027 // ( 1.3.6.1.4.1.1466.115.121.1.41 DESC 'Postal Address' )
2028 //
2029 // This syntax corresponds to the PostalAddress ASN.1 type from [X.520];
2030 // that is
2031 //
2032 // PostalAddress ::= SEQUENCE SIZE(1..ub-postal-line) OF
2033 // DirectoryString { ub-postal-string }
2034 //
2035 // The values of ub-postal-line and ub-postal-string (both integers) are
2036 // implementation defined. Non-normative definitions appear in [X.520].
2037 //
2038 .oid = "1.3.6.1.4.1.1466.115.121.1.41",
2039 .name = "PostalAddress",
2040 .desc = "Postal Address",
2041 .flags = LDAPSCHEMA_O_READABLE,
2042 .type = LDAPSCHEMA_SYNTAX,
2043 .class = LDAPSCHEMA_CLASS_UTF8,
2044 .def = "( 1.3.6.1.4.1.1466.115.121.1.41 DESC 'Postal Address' )",
2045 .abnf = "PostalAddress = line *( DOLLAR line )\n"
2046 "line = 1*line-char\n"
2047 "line-char = %x00-23\n"
2048 " / (%x5C \"24\") ; escaped \"$\"\n"
2049 " / %x25-5B\n"
2050 " / (%x5C \"5C\") ; escaped \"\\\"\n"
2051 " / %x5D-7F\n"
2052 " / UTFMB\n"
2053 "\n"
2054 "UTFMB = UTF2 / UTF3 / UTF4\n"
2055 "UTF0 = %x80-BF\n"
2056 "UTF1 = %x00-7F\n"
2057 "UTF2 = %xC2-DF UTF0\n"
2058 "UTF3 = %xE0 %xA0-BF UTF0 / %xE1-EC 2(UTF0) /\n"
2059 " %xED %x80-9F UTF0 / %xEE-EF 2(UTF0)\n"
2060 "UTF4 = %xF0 %x90-BF 2(UTF0) / %xF1-F3 3(UTF0) /\n"
2061 " %xF4 %x80-8F 2(UTF0)\n",
2062 .re_posix = NULL,
2063 .re_pcre = NULL,
2064 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
2065 .spec_type = LDAPSCHEMA_SPEC_RFC,
2066 .spec_name = "4517",
2067 .spec_section = "3.3.28",
2068 .spec_source = NULL,
2069 .spec_vendor = "IETF",
2070 .examples = (const char *[])
2071 {
2072 "1234 Main St.$Anytown, CA 12345$USA",
2073 "\\241,000,000 Sweepstakes$PO Box 1000000$Anytown, CA 12345$USA",
2074 NULL,
2075 },
2076};
2077
2078
2079
2080{
2081 //
2082 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
2083 //
2084 // 3.3.29. Printable String
2085 //
2086 // A value of the Printable String syntax is a string of one or more
2087 // latin alphabetic, numeric, and selected punctuation characters as
2088 // specified by the <PrintableCharacter> rule in Section 3.2.
2089 //
2090 // The LDAP-specific encoding of a value of this syntax is the
2091 // unconverted string of characters, which conforms to the
2092 // <PrintableString> rule in Section 3.2.
2093 //
2094 // Example:
2095 // This is a PrintableString.
2096 //
2097 // The LDAP definition for the PrintableString syntax is:
2098 //
2099 // ( 1.3.6.1.4.1.1466.115.121.1.44 DESC 'Printable String' )
2100 //
2101 // This syntax corresponds to the PrintableString ASN.1 type from
2102 // [ASN.1].
2103 //
2104 .oid = "1.3.6.1.4.1.1466.115.121.1.44",
2105 .name = "PrintableString",
2106 .desc = "Printable String",
2107 .flags = LDAPSCHEMA_O_READABLE,
2108 .type = LDAPSCHEMA_SYNTAX,
2109 .class = LDAPSCHEMA_CLASS_ASCII,
2110 .def = "( 1.3.6.1.4.1.1466.115.121.1.44 DESC 'Printable String' )",
2111 .abnf = "PrintableCharacter = ALPHA / DIGIT / SQUOTE / LPAREN / RPAREN /\n"
2112 " PLUS / COMMA / HYPHEN / DOT / EQUALS /\n"
2113 " SLASH / COLON / QUESTION / SPACE\n"
2114 "PrintableString = 1*PrintableCharacter\n"
2115 "IA5String = *(%x00-7F)\n"
2116 "SLASH = %x2F ; forward slash (\"/\")\n"
2117 "COLON = %x3A ; colon (\":\")\n"
2118 "QUESTION = %x3F ; question mark (\"?\")\n"
2119 "ALPHA = %x41-5A / %x61-7A ; \"A\"-\"Z\" / \"a\"-\"z\"\n"
2120 "DIGIT = %x30 / LDIGIT ; \"0\"-\"9\"\n"
2121 "LDIGIT = %x31-39 ; \"1\"-\"9\"\n"
2122 "SQUOTE = %x27 ; single quote (\"'\")\n"
2123 "LPAREN = %x28 ; left paren (\"(\")\n"
2124 "RPAREN = %x29 ; right paren (\")\")\n"
2125 "PLUS = %x2B ; plus sign (\"+\")\n"
2126 "COMMA = %x2C ; comma (\",\")\n"
2127 "HYPHEN = %x2D ; hyphen (\"-\")\n"
2128 "DOT = %x2E ; period (\".\")\n"
2129 "EQUALS = %x3D ; equals sign (\"=\")\n"
2130 "SPACE = %x20 ; space (\" \")\n",
2131 .re_posix = NULL,
2132 .re_pcre = NULL,
2133 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
2134 .spec_type = LDAPSCHEMA_SPEC_RFC,
2135 .spec_name = "4517",
2136 .spec_section = "3.3.29",
2137 .spec_source = NULL,
2138 .spec_vendor = "IETF",
2139 .examples = (const char *[])
2140 {
2141 "This is a PrintableString.",
2142 NULL,
2143 },
2144};
2145
2146
2147
2148{
2149 //
2150 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
2151 //
2152 // 3.3.30. Substring Assertion
2153 //
2154 // A value of the Substring Assertion syntax is a sequence of zero, one,
2155 // or more character substrings used as an argument for substring
2156 // extensible matching of character string attribute values; i.e., as
2157 // the matchValue of a MatchingRuleAssertion [RFC4511]. Each substring
2158 // is a string of one or more arbitrary characters from the Universal
2159 // Character Set (UCS) [UCS]. A zero-length substring is not permitted.
2160 //
2161 // The LDAP-specific encoding of a value of this syntax is defined by
2162 // the following ABNF:
2163 //
2164 // SubstringAssertion = [ initial ] any [ final ]
2165 //
2166 // initial = substring
2167 // any = ASTERISK *(substring ASTERISK)
2168 // final = substring
2169 // ASTERISK = %x2A ; asterisk ("*")
2170 //
2171 // substring = 1*substring-character
2172 // substring-character = %x00-29
2173 // / (%x5C "2A") ; escaped "*"
2174 // / %x2B-5B
2175 // / (%x5C "5C") ; escaped "\"
2176 // / %x5D-7F
2177 // / UTFMB
2178 //
2179 // Each <substring> of a Substring Assertion value is encoded as a UTF-8
2180 // [RFC3629] string, except that "\" and "*" characters, if they occur
2181 // in the substring, are escaped by a "\" character followed by the two
2182 // hexadecimal digit code for the character.
2183 //
2184 // The Substring Assertion syntax is used only as the syntax of
2185 // assertion values in the extensible match. It is not used as an
2186 // attribute syntax, or in the SubstringFilter [RFC4511].
2187 //
2188 // The LDAP definition for the Substring Assertion syntax is:
2189 //
2190 // ( 1.3.6.1.4.1.1466.115.121.1.58 DESC 'Substring Assertion' )
2191 //
2192 // This syntax corresponds to the SubstringAssertion ASN.1 type from
2193 // [X.520].
2194 //
2195 .oid = "1.3.6.1.4.1.1466.115.121.1.58",
2196 .name = "SubstringAssertion",
2197 .desc = "Substring Assertion",
2198 .flags = LDAPSCHEMA_O_READABLE,
2199 .type = LDAPSCHEMA_SYNTAX,
2200 .class = LDAPSCHEMA_CLASS_UTF8,
2201 .def = "( 1.3.6.1.4.1.1466.115.121.1.58 DESC 'Substring Assertion' )",
2202 .abnf = "SubstringAssertion = [ initial ] any [ final ]\n"
2203 "\n"
2204 "initial = substring\n"
2205 "any = ASTERISK *(substring ASTERISK)\n"
2206 "final = substring\n"
2207 "ASTERISK = %x2A ; asterisk (\"*\")\n"
2208 "\n"
2209 "substring = 1*substring-character\n"
2210 "substring-character = %x00-29\n"
2211 " / (%x5C \"2A\") ; escaped \"*\"\n"
2212 " / %x2B-5B\n"
2213 " / (%x5C \"5C\") ; escaped \"\\\"\n"
2214 " / %x5D-7F\n"
2215 " / UTFMB\n"
2216 "\n"
2217 "UTFMB = UTF2 / UTF3 / UTF4\n"
2218 "UTF0 = %x80-BF\n"
2219 "UTF1 = %x00-7F\n"
2220 "UTF2 = %xC2-DF UTF0\n"
2221 "UTF3 = %xE0 %xA0-BF UTF0 / %xE1-EC 2(UTF0) /\n"
2222 " %xED %x80-9F UTF0 / %xEE-EF 2(UTF0)\n"
2223 "UTF4 = %xF0 %x90-BF 2(UTF0) / %xF1-F3 3(UTF0) /\n"
2224 " %xF4 %x80-8F 2(UTF0)\n",
2225 .re_posix = NULL,
2226 .re_pcre = NULL,
2227 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
2228 .spec_type = LDAPSCHEMA_SPEC_RFC,
2229 .spec_name = "4517",
2230 .spec_section = "3.3.30",
2231 .spec_source = NULL,
2232 .spec_vendor = "IETF",
2233 .examples = NULL,
2234};
2235
2236
2237
2238{
2239 //
2240 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
2241 //
2242 // 3.3.31. Telephone Number
2243 //
2244 // A value of the Telephone Number syntax is a string of printable
2245 // characters that complies with the internationally agreed format for
2246 // representing international telephone numbers [E.123].
2247 //
2248 // The LDAP-specific encoding of a value of this syntax is the
2249 // unconverted string of characters, which conforms to the
2250 // <PrintableString> rule in Section 3.2.
2251 //
2252 // Examples:
2253 // +1 512 315 0280
2254 // +1-512-315-0280
2255 // +61 3 9896 7830
2256 //
2257 // The LDAP definition for the Telephone Number syntax is:
2258 //
2259 // ( 1.3.6.1.4.1.1466.115.121.1.50 DESC 'Telephone Number' )
2260 //
2261 // The Telephone Number syntax corresponds to the following ASN.1 type
2262 // from [X.520]:
2263 //
2264 // PrintableString (SIZE(1..ub-telephone-number))
2265 //
2266 // The value of ub-telephone-number (an integer) is implementation
2267 // defined. A non-normative definition appears in [X.520].
2268 //
2269 .oid = "1.3.6.1.4.1.1466.115.121.1.50",
2270 .name = "TelephoneNumber",
2271 .desc = "Telephone Number",
2272 .flags = LDAPSCHEMA_O_READABLE,
2273 .type = LDAPSCHEMA_SYNTAX,
2274 .class = LDAPSCHEMA_CLASS_UTF8,
2275 .def = "( 1.3.6.1.4.1.1466.115.121.1.50 DESC 'Telephone Number' )",
2276 .abnf = NULL,
2277 .re_posix = NULL,
2278 .re_pcre = NULL,
2279 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
2280 .spec_type = LDAPSCHEMA_SPEC_RFC,
2281 .spec_name = "4517",
2282 .spec_section = "3.3.31",
2283 .spec_source = NULL,
2284 .spec_vendor = "IETF",
2285 .examples = (const char *[])
2286 {
2287 "+1 512 315 0280",
2288 "+1-512-315-0280",
2289 "+61 3 9896 7830",
2290 NULL,
2291 },
2292};
2293
2294
2295
2296{
2297 //
2298 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
2299 //
2300 // 3.3.32. Teletex Terminal Identifier
2301 //
2302 // A value of this syntax specifies the identifier and (optionally)
2303 // parameters of a teletex terminal.
2304 //
2305 // The LDAP-specific encoding of a value of this syntax is defined by
2306 // the following ABNF:
2307 //
2308 // teletex-id = ttx-term *(DOLLAR ttx-param)
2309 // ttx-term = PrintableString ; terminal identifier
2310 // ttx-param = ttx-key COLON ttx-value ; parameter
2311 // ttx-key = "graphic" / "control" / "misc" / "page" / "private"
2312 // ttx-value = *ttx-value-octet
2313 //
2314 // ttx-value-octet = %x00-23
2315 // / (%x5C "24") ; escaped "$"
2316 // / %x25-5B
2317 // / (%x5C "5C") ; escaped "\"
2318 // / %x5D-FF
2319 //
2320 // The <PrintableString> and <COLON> rules are defined in Section 3.2.
2321 // The <DOLLAR> rule is defined in [RFC4512].
2322 //
2323 // The LDAP definition for the Teletex Terminal Identifier syntax is:
2324 //
2325 // ( 1.3.6.1.4.1.1466.115.121.1.51
2326 // DESC 'Teletex Terminal Identifier' )
2327 //
2328 // This syntax corresponds to the TeletexTerminalIdentifier ASN.1 type
2329 // from [X.520].
2330 //
2331 .oid = "1.3.6.1.4.1.1466.115.121.1.51",
2332 .name = "teletex-id",
2333 .desc = "Teletex Terminal Identifier",
2334 .flags = LDAPSCHEMA_O_READABLE | LDAPSCHEMA_O_COMMON_ABNF,
2335 .type = LDAPSCHEMA_SYNTAX,
2336 .class = LDAPSCHEMA_CLASS_ASCII,
2337 .def = "( 1.3.6.1.4.1.1466.115.121.1.51 DESC 'Teletex Terminal Identifier' )",
2338 .abnf = "teletex-id = ttx-term *(DOLLAR ttx-param)\n"
2339 "ttx-term = PrintableString ; terminal identifier\n"
2340 "ttx-param = ttx-key COLON ttx-value ; parameter\n"
2341 "ttx-key = \"graphic\" / \"control\" / \"misc\" / \"page\" / \"private\"\n"
2342 "ttx-value = *ttx-value-octet\n"
2343 " \n"
2344 "ttx-value-octet = %x00-23\n"
2345 " / (%x5C \"24\") ; escaped \"$\"\n"
2346 " / %x25-5B\n"
2347 " / (%x5C \"5C\") ; escaped \"\\\"\n"
2348 " / %x5D-FF\n",
2349 .re_posix = NULL,
2350 .re_pcre = NULL,
2351 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
2352 .spec_type = LDAPSCHEMA_SPEC_RFC,
2353 .spec_name = "4517",
2354 .spec_section = "3.3.32",
2355 .spec_source = NULL,
2356 .spec_vendor = "IETF",
2357 .examples = NULL,
2358};
2359
2360
2361
2362{
2363 //
2364 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
2365 //
2366 // 3.3.33. Telex Number
2367 //
2368 // A value of the Telex Number syntax specifies the telex number,
2369 // country code, and answerback code of a telex terminal.
2370 //
2371 // The LDAP-specific encoding of a value of this syntax is defined by
2372 // the following ABNF:
2373 //
2374 // telex-number = actual-number DOLLAR country-code
2375 // DOLLAR answerback
2376 // actual-number = PrintableString
2377 // country-code = PrintableString
2378 // answerback = PrintableString
2379 //
2380 // The <PrintableString> rule is defined in Section 3.2. The <DOLLAR>
2381 // rule is defined in [RFC4512].
2382 //
2383 // The LDAP definition for the Telex Number syntax is:
2384 //
2385 // ( 1.3.6.1.4.1.1466.115.121.1.52 DESC 'Telex Number' )
2386 //
2387 // This syntax corresponds to the TelexNumber ASN.1 type from [X.520].
2388 //
2389 .oid = "1.3.6.1.4.1.1466.115.121.1.52",
2390 .name = "telex-number",
2391 .desc = "Telex Number",
2392 .flags = LDAPSCHEMA_O_READABLE | LDAPSCHEMA_O_COMMON_ABNF,
2393 .type = LDAPSCHEMA_SYNTAX,
2394 .class = LDAPSCHEMA_CLASS_UTF8,
2395 .def = "( 1.3.6.1.4.1.1466.115.121.1.52 DESC 'Telex Number' )",
2396 .abnf = "telex-number = actual-number DOLLAR country-code\n"
2397 " DOLLAR answerback\n"
2398 "actual-number = PrintableString\n"
2399 "country-code = PrintableString\n"
2400 "answerback = PrintableString\n",
2401 .re_posix = NULL,
2402 .re_pcre = NULL,
2403 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
2404 .spec_type = LDAPSCHEMA_SPEC_RFC,
2405 .spec_name = "4517",
2406 .spec_section = "3.3.33",
2407 .spec_source = NULL,
2408 .spec_vendor = "IETF",
2409 .examples = NULL,
2410};
2411
2412
2413
2414{
2415 //
2416 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
2417 //
2418 // 3.3.34. UTC Time
2419 //
2420 // A value of the UTC Time syntax is a character string representing a
2421 // date and time to a precision of one minute or one second. The year
2422 // is given as a two-digit number. The LDAP-specific encoding of a
2423 // value of this syntax follows the format defined in [ASN.1] for the
2424 // UTCTime type and is described by the following ABNF:
2425 //
2426 // UTCTime = year month day hour minute [ second ]
2427 // [ u-time-zone ]
2428 // u-time-zone = %x5A ; "Z"
2429 // / u-differential
2430 // u-differential = ( MINUS / PLUS ) hour minute
2431 //
2432 // The <year>, <month>, <day>, <hour>, <minute>, <second>, and <MINUS>
2433 // rules are defined in Section 3.3.13. The <PLUS> rule is defined in
2434 // [RFC4512].
2435 //
2436 // The above ABNF allows character strings that do not represent valid
2437 // dates (in the Gregorian calendar) and/or valid times. Such character
2438 // strings SHOULD be considered invalid for this syntax.
2439 //
2440 // The time value represents coordinated universal time if the "Z" form
2441 // of <u-time-zone> is used; otherwise, the value represents a local
2442 // time. In the latter case, if <u-differential> is provided, then
2443 // coordinated universal time can be calculated by subtracting the
2444 // differential from the local time. The <u-time-zone> SHOULD be
2445 // present in time values, and the "Z" form of <u-time-zone> SHOULD be
2446 // used in preference to <u-differential>.
2447 //
2448 // The LDAP definition for the UTC Time syntax is:
2449 //
2450 // ( 1.3.6.1.4.1.1466.115.121.1.53 DESC 'UTC Time' )
2451 //
2452 // Note: This syntax is deprecated in favor of the Generalized Time
2453 // syntax.
2454 //
2455 // The UTC Time syntax corresponds to the UTCTime ASN.1 type from
2456 // [ASN.1].
2457 //
2458 .oid = "1.3.6.1.4.1.1466.115.121.1.53",
2459 .name = "UTCTime",
2460 .desc = "UTC Time",
2461 .flags = LDAPSCHEMA_O_READABLE,
2462 .type = LDAPSCHEMA_SYNTAX,
2463 .class = LDAPSCHEMA_CLASS_ASCII,
2464 .def = "( 1.3.6.1.4.1.1466.115.121.1.53 DESC 'UTC Time' )",
2465 .abnf = "UTCTime = year month day hour minute [ second ]\n"
2466 " [ u-time-zone ]\n"
2467 "u-time-zone = %x5A ; \"Z\" \n"
2468 " / u-differential\n"
2469 "u-differential = ( MINUS / PLUS ) hour minute\n"
2470 "\n"
2471 "year = 2(%x30-39) ; \"00\" to \"99\"\n"
2472 "month = ( %x30 %x31-39 ) ; \"01\" (January) to \"09\"\n"
2473 " / ( %x31 %x30-32 ) ; \"10\" to \"12\"\n"
2474 "day = ( %x30 %x31-39 ) ; \"01\" to \"09\"\n"
2475 " / ( %x31-32 %x30-39 ) ; \"10\" to \"29\"\n"
2476 " / ( %x33 %x30-31 ) ; \"30\" to \"31\"\n"
2477 "hour = ( %x30-31 %x30-39 ) / ( %x32 %x30-33 ) ; \"00\" to \"23\"\n"
2478 "minute = %x30-35 %x30-39 ; \"00\" to \"59\"\n"
2479 "\n"
2480 "second = ( %x30-35 %x30-39 ) ; \"00\" to \"59\"\n"
2481 "\n"
2482 "MINUS = %x2D ; minus sign (\"-\")\n"
2483 "PLUS = %x2B ; plus sign (\"+\")\n",
2484 .re_posix = NULL,
2485 .re_pcre = NULL,
2486 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
2487 .spec_type = LDAPSCHEMA_SPEC_RFC,
2488 .spec_name = "4517",
2489 .spec_section = "3.3.34",
2490 .spec_source = NULL,
2491 .spec_vendor = "IETF",
2492 .examples = NULL,
2493};
2494
2495
2496
2497{
2498 //
2499 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
2500 //
2501 // 4.2.1. bitStringMatch
2502 //
2503 // The bitStringMatch rule compares an assertion value of the Bit String
2504 // syntax to an attribute value of a syntax (e.g., the Bit String
2505 // syntax) whose corresponding ASN.1 type is BIT STRING.
2506 // If the corresponding ASN.1 type of the attribute syntax does not have
2507 // a named bit list [ASN.1] (which is the case for the Bit String
2508 // syntax), then the rule evaluates to TRUE if and only if the attribute
2509 // value has the same number of bits as the assertion value and the bits
2510 // match on a bitwise basis.
2511 //
2512 // If the corresponding ASN.1 type does have a named bit list, then
2513 // bitStringMatch operates as above, except that trailing zero bits in
2514 // the attribute and assertion values are treated as absent.
2515 //
2516 // The LDAP definition for the bitStringMatch rule is:
2517 //
2518 // ( 2.5.13.16 NAME 'bitStringMatch'
2519 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.6 )
2520 //
2521 // The bitStringMatch rule is an equality matching rule.
2522 //
2523 .oid = "2.5.13.16",
2524 .name = "bitStringMatch",
2525 .desc = "bitStringMatch",
2526 .type = LDAPSCHEMA_MATCHINGRULE,
2527 .def = "( 2.5.13.16 NAME 'bitStringMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.6 )",
2528 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
2529 .spec_type = LDAPSCHEMA_SPEC_RFC,
2530 .spec_name = "4517",
2531 .spec_section = "4.2.1",
2532 .spec_source = NULL,
2533 .spec_vendor = "IETF",
2534};
2535
2536
2537
2538{
2539 //
2540 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
2541 //
2542 // 4.2.2. booleanMatch
2543 //
2544 // The booleanMatch rule compares an assertion value of the Boolean
2545 // syntax to an attribute value of a syntax (e.g., the Boolean syntax)
2546 // whose corresponding ASN.1 type is BOOLEAN.
2547 //
2548 // The rule evaluates to TRUE if and only if the attribute value and the
2549 // assertion value are both TRUE or both FALSE.
2550 //
2551 // The LDAP definition for the booleanMatch rule is:
2552 //
2553 // ( 2.5.13.13 NAME 'booleanMatch'
2554 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 )
2555 //
2556 // The booleanMatch rule is an equality matching rule.
2557 //
2558 .oid = "2.5.13.13",
2559 .name = "booleanMatch",
2560 .desc = "booleanMatch",
2561 .type = LDAPSCHEMA_MATCHINGRULE,
2562 .def = "( 2.5.13.13 NAME 'booleanMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 )",
2563 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
2564 .spec_type = LDAPSCHEMA_SPEC_RFC,
2565 .spec_name = "4517",
2566 .spec_section = "4.2.2",
2567 .spec_source = NULL,
2568 .spec_vendor = "IETF",
2569};
2570
2571
2572
2573{
2574 //
2575 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
2576 //
2577 // 4.2.3. caseExactIA5Match
2578 //
2579 // The caseExactIA5Match rule compares an assertion value of the IA5
2580 // String syntax to an attribute value of a syntax (e.g., the IA5 String
2581 // syntax) whose corresponding ASN.1 type is IA5String.
2582 //
2583 // The rule evaluates to TRUE if and only if the prepared attribute
2584 // value character string and the prepared assertion value character
2585 // string have the same number of characters and corresponding
2586 // characters have the same code point.
2587 //
2588 // In preparing the attribute value and assertion value for comparison,
2589 // characters are not case folded in the Map preparation step, and only
2590 // Insignificant Space Handling is applied in the Insignificant
2591 // Character Handling step.
2592 //
2593 // The LDAP definition for the caseExactIA5Match rule is:
2594 //
2595 // ( 1.3.6.1.4.1.1466.109.114.1 NAME 'caseExactIA5Match'
2596 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )
2597 //
2598 // The caseExactIA5Match rule is an equality matching rule.
2599 //
2600 .oid = "1.3.6.1.4.1.1466.109.114.1",
2601 .name = "caseExactIA5Match",
2602 .desc = "caseExactIA5Match",
2603 .type = LDAPSCHEMA_MATCHINGRULE,
2604 .def = "( 1.3.6.1.4.1.1466.109.114.1 NAME 'caseExactIA5Match' SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
2605 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
2606 .spec_type = LDAPSCHEMA_SPEC_RFC,
2607 .spec_name = "4517",
2608 .spec_section = "4.2.3",
2609 .spec_source = NULL,
2610 .spec_vendor = "IETF",
2611};
2612
2613
2614
2615{
2616 //
2617 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
2618 //
2619 // 4.2.4. caseExactMatch
2620 //
2621 // The caseExactMatch rule compares an assertion value of the Directory
2622 // String syntax to an attribute value of a syntax (e.g., the Directory
2623 // String, Printable String, Country String, or Telephone Number syntax)
2624 // whose corresponding ASN.1 type is DirectoryString or one of the
2625 // alternative string types of DirectoryString, such as PrintableString
2626 // (the other alternatives do not correspond to any syntax defined in
2627 // this document).
2628 //
2629 // The rule evaluates to TRUE if and only if the prepared attribute
2630 // value character string and the prepared assertion value character
2631 // string have the same number of characters and corresponding
2632 // characters have the same code point.
2633 //
2634 // In preparing the attribute value and assertion value for comparison,
2635 // characters are not case folded in the Map preparation step, and only
2636 // Insignificant Space Handling is applied in the Insignificant
2637 // Character Handling step.
2638 //
2639 // The LDAP definition for the caseExactMatch rule is:
2640 //
2641 // ( 2.5.13.5 NAME 'caseExactMatch'
2642 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )
2643 //
2644 // The caseExactMatch rule is an equality matching rule.
2645 //
2646 .oid = "2.5.13.5",
2647 .name = "caseExactMatch",
2648 .desc = "caseExactMatch",
2649 .type = LDAPSCHEMA_MATCHINGRULE,
2650 .def = "( 2.5.13.5 NAME 'caseExactMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
2651 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
2652 .spec_type = LDAPSCHEMA_SPEC_RFC,
2653 .spec_name = "4517",
2654 .spec_section = "4.2.4",
2655 .spec_source = NULL,
2656 .spec_vendor = "IETF",
2657};
2658
2659
2660
2661{
2662 //
2663 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
2664 //
2665 // 4.2.5. caseExactOrderingMatch
2666 //
2667 // The caseExactOrderingMatch rule compares an assertion value of the
2668 // Directory String syntax to an attribute value of a syntax (e.g., the
2669 // Directory String, Printable String, Country String, or Telephone
2670 // Number syntax) whose corresponding ASN.1 type is DirectoryString or
2671 // one of its alternative string types.
2672 //
2673 // The rule evaluates to TRUE if and only if, in the code point
2674 // collation order, the prepared attribute value character string
2675 // appears earlier than the prepared assertion value character string;
2676 // i.e., the attribute value is "less than" the assertion value.
2677 //
2678 // In preparing the attribute value and assertion value for comparison,
2679 // characters are not case folded in the Map preparation step, and only
2680 // Insignificant Space Handling is applied in the Insignificant
2681 // Character Handling step.
2682 //
2683 // The LDAP definition for the caseExactOrderingMatch rule is:
2684 //
2685 // ( 2.5.13.6 NAME 'caseExactOrderingMatch'
2686 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )
2687 //
2688 // The caseExactOrderingMatch rule is an ordering matching rule.
2689 //
2690 .oid = "2.5.13.6",
2691 .name = "caseExactOrderingMatch",
2692 .desc = "caseExactOrderingMatch",
2693 .type = LDAPSCHEMA_MATCHINGRULE,
2694 .def = "( 2.5.13.6 NAME 'caseExactOrderingMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
2695 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
2696 .spec_type = LDAPSCHEMA_SPEC_RFC,
2697 .spec_name = "4517",
2698 .spec_section = "4.2.5",
2699 .spec_source = NULL,
2700 .spec_vendor = "IETF",
2701};
2702
2703
2704
2705{
2706 //
2707 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
2708 //
2709 // 4.2.6. caseExactSubstringsMatch
2710 //
2711 // The caseExactSubstringsMatch rule compares an assertion value of the
2712 // Substring Assertion syntax to an attribute value of a syntax (e.g.,
2713 // the Directory String, Printable String, Country String, or Telephone
2714 // Number syntax) whose corresponding ASN.1 type is DirectoryString or
2715 // one of its alternative string types.
2716 //
2717 // The rule evaluates to TRUE if and only if (1) the prepared substrings
2718 // of the assertion value match disjoint portions of the prepared
2719 // attribute value character string in the order of the substrings in
2720 // the assertion value, (2) an <initial> substring, if present, matches
2721 // the beginning of the prepared attribute value character string, and
2722 // (3) a <final> substring, if present, matches the end of the prepared
2723 // attribute value character string. A prepared substring matches a
2724 // portion of the prepared attribute value character string if
2725 // corresponding characters have the same code point.
2726 //
2727 // In preparing the attribute value and assertion value substrings for
2728 // comparison, characters are not case folded in the Map preparation
2729 // step, and only Insignificant Space Handling is applied in the
2730 // Insignificant Character Handling step.
2731 //
2732 // The LDAP definition for the caseExactSubstringsMatch rule is:
2733 //
2734 // ( 2.5.13.7 NAME 'caseExactSubstringsMatch'
2735 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )
2736 //
2737 // The caseExactSubstringsMatch rule is a substrings matching rule.
2738 //
2739 .oid = "2.5.13.7",
2740 .name = "caseExactSubstringsMatch",
2741 .desc = "caseExactSubstringsMatch",
2742 .type = LDAPSCHEMA_MATCHINGRULE,
2743 .def = "( 2.5.13.7 NAME 'caseExactSubstringsMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
2744 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
2745 .spec_type = LDAPSCHEMA_SPEC_RFC,
2746 .spec_name = "4517",
2747 .spec_section = "4.2.6",
2748 .spec_source = NULL,
2749 .spec_vendor = "IETF",
2750};
2751
2752
2753
2754{
2755 //
2756 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
2757 //
2758 // 4.2.7. caseIgnoreIA5Match
2759 //
2760 // The caseIgnoreIA5Match rule compares an assertion value of the IA5
2761 // String syntax to an attribute value of a syntax (e.g., the IA5 String
2762 // syntax) whose corresponding ASN.1 type is IA5String.
2763 //
2764 // The rule evaluates to TRUE if and only if the prepared attribute
2765 // value character string and the prepared assertion value character
2766 // string have the same number of characters and corresponding
2767 // characters have the same code point.
2768 //
2769 // In preparing the attribute value and assertion value for comparison,
2770 // characters are case folded in the Map preparation step, and only
2771 // Insignificant Space Handling is applied in the Insignificant
2772 // Character Handling step.
2773 //
2774 // The LDAP definition for the caseIgnoreIA5Match rule is:
2775 //
2776 // ( 1.3.6.1.4.1.1466.109.114.2 NAME 'caseIgnoreIA5Match'
2777 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )
2778 //
2779 // The caseIgnoreIA5Match rule is an equality matching rule.
2780 //
2781 .oid = "1.3.6.1.4.1.1466.109.114.2",
2782 .name = "caseIgnoreIA5Match",
2783 .desc = "caseIgnoreIA5Match",
2784 .type = LDAPSCHEMA_MATCHINGRULE,
2785 .def = "( 1.3.6.1.4.1.1466.109.114.2 NAME 'caseIgnoreIA5Match' SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
2786 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
2787 .spec_type = LDAPSCHEMA_SPEC_RFC,
2788 .spec_name = "4517",
2789 .spec_section = "4.2.7",
2790 .spec_source = NULL,
2791 .spec_vendor = "IETF",
2792};
2793
2794
2795
2796{
2797 //
2798 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
2799 //
2800 // 4.2.8. caseIgnoreIA5SubstringsMatch
2801 //
2802 // The caseIgnoreIA5SubstringsMatch rule compares an assertion value of
2803 // the Substring Assertion syntax to an attribute value of a syntax
2804 // (e.g., the IA5 String syntax) whose corresponding ASN.1 type is
2805 // IA5String.
2806 //
2807 // The rule evaluates to TRUE if and only if (1) the prepared substrings
2808 // of the assertion value match disjoint portions of the prepared
2809 // attribute value character string in the order of the substrings in
2810 // the assertion value, (2) an <initial> substring, if present, matches
2811 // the beginning of the prepared attribute value character string, and
2812 // (3) a <final> substring, if present, matches the end of the prepared
2813 // attribute value character string. A prepared substring matches a
2814 // portion of the prepared attribute value character string if
2815 // corresponding characters have the same code point.
2816 //
2817 // In preparing the attribute value and assertion value substrings for
2818 // comparison, characters are case folded in the Map preparation step,
2819 // and only Insignificant Space Handling is applied in the Insignificant
2820 // Character Handling step.
2821 //
2822 // ( 1.3.6.1.4.1.1466.109.114.3 NAME 'caseIgnoreIA5SubstringsMatch'
2823 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )
2824 //
2825 // The caseIgnoreIA5SubstringsMatch rule is a substrings matching rule.
2826 //
2827 .oid = "1.3.6.1.4.1.1466.109.114.3",
2828 .name = "caseIgnoreIA5SubstringsMatch",
2829 .desc = "caseIgnoreIA5SubstringsMatch",
2830 .type = LDAPSCHEMA_MATCHINGRULE,
2831 .def = "( 1.3.6.1.4.1.1466.109.114.3 NAME 'caseIgnoreIA5SubstringsMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
2832 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
2833 .spec_type = LDAPSCHEMA_SPEC_RFC,
2834 .spec_name = "4517",
2835 .spec_section = "4.2.8",
2836 .spec_source = NULL,
2837 .spec_vendor = "IETF",
2838};
2839
2840
2841
2842{
2843 //
2844 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
2845 //
2846 // 4.2.9. caseIgnoreListMatch
2847 //
2848 // The caseIgnoreListMatch rule compares an assertion value that is a
2849 // sequence of strings to an attribute value of a syntax (e.g., the
2850 //
2851 // Postal Address syntax) whose corresponding ASN.1 type is a SEQUENCE
2852 // OF the DirectoryString ASN.1 type.
2853 //
2854 // The rule evaluates to TRUE if and only if the attribute value and the
2855 // assertion value have the same number of strings and corresponding
2856 // strings (by position) match according to the caseIgnoreMatch matching
2857 // rule.
2858 //
2859 // In [X.520], the assertion syntax for this matching rule is defined to
2860 // be:
2861 //
2862 // SEQUENCE OF DirectoryString {ub-match}
2863 //
2864 // That is, it is different from the corresponding type for the Postal
2865 // Address syntax. The choice of the Postal Address syntax for the
2866 // assertion syntax of the caseIgnoreListMatch in LDAP should not be
2867 // seen as limiting the matching rule to apply only to attributes with
2868 // the Postal Address syntax.
2869 //
2870 // The LDAP definition for the caseIgnoreListMatch rule is:
2871 //
2872 // ( 2.5.13.11 NAME 'caseIgnoreListMatch'
2873 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.41 )
2874 //
2875 // The caseIgnoreListMatch rule is an equality matching rule.
2876 //
2877 .oid = "2.5.13.11",
2878 .name = "caseIgnoreListMatch",
2879 .desc = "caseIgnoreListMatch",
2880 .type = LDAPSCHEMA_MATCHINGRULE,
2881 .def = "( 2.5.13.11 NAME 'caseIgnoreListMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.41 )",
2882 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
2883 .spec_type = LDAPSCHEMA_SPEC_RFC,
2884 .spec_name = "4517",
2885 .spec_section = "4.2.9",
2886 .spec_source = NULL,
2887 .spec_vendor = "IETF",
2888};
2889
2890
2891
2892{
2893 //
2894 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
2895 //
2896 // 4.2.10. caseIgnoreListSubstringsMatch
2897 //
2898 // The caseIgnoreListSubstringsMatch rule compares an assertion value of
2899 // the Substring Assertion syntax to an attribute value of a syntax
2900 // (e.g., the Postal Address syntax) whose corresponding ASN.1 type is a
2901 // SEQUENCE OF the DirectoryString ASN.1 type.
2902 //
2903 // The rule evaluates to TRUE if and only if the assertion value
2904 // matches, per the caseIgnoreSubstringsMatch rule, the character string
2905 // formed by concatenating the strings of the attribute value, except
2906 // that none of the <initial>, <any>, or <final> substrings of the
2907 // assertion value are considered to match a substring of the
2908 // concatenated string which spans more than one of the original strings
2909 // of the attribute value.
2910 //
2911 // Note that, in terms of the LDAP-specific encoding of the Postal
2912 // Address syntax, the concatenated string omits the <DOLLAR> line
2913 // separator and the escaping of "\" and "$" characters.
2914 //
2915 // The LDAP definition for the caseIgnoreListSubstringsMatch rule is:
2916 //
2917 // ( 2.5.13.12 NAME 'caseIgnoreListSubstringsMatch'
2918 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )
2919 //
2920 // The caseIgnoreListSubstringsMatch rule is a substrings matching rule.
2921 //
2922 .oid = "2.5.13.12",
2923 .name = "caseIgnoreListSubstringsMatch",
2924 .desc = "caseIgnoreListSubstringsMatch",
2925 .type = LDAPSCHEMA_MATCHINGRULE,
2926 .def = "( 2.5.13.12 NAME 'caseIgnoreListSubstringsMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
2927 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
2928 .spec_type = LDAPSCHEMA_SPEC_RFC,
2929 .spec_name = "4517",
2930 .spec_section = "4.2.10",
2931 .spec_source = NULL,
2932 .spec_vendor = "IETF",
2933};
2934
2935
2936
2937{
2938 //
2939 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
2940 //
2941 // 4.2.11. caseIgnoreMatch
2942 //
2943 // The caseIgnoreMatch rule compares an assertion value of the Directory
2944 // String syntax to an attribute value of a syntax (e.g., the Directory
2945 // String, Printable String, Country String, or Telephone Number syntax)
2946 // whose corresponding ASN.1 type is DirectoryString or one of its
2947 // alternative string types.
2948 //
2949 // The rule evaluates to TRUE if and only if the prepared attribute
2950 // value character string and the prepared assertion value character
2951 // string have the same number of characters and corresponding
2952 // characters have the same code point.
2953 //
2954 // In preparing the attribute value and assertion value for comparison,
2955 // characters are case folded in the Map preparation step, and only
2956 // Insignificant Space Handling is applied in the Insignificant
2957 // Character Handling step.
2958 //
2959 // The LDAP definition for the caseIgnoreMatch rule is:
2960 //
2961 // ( 2.5.13.2 NAME 'caseIgnoreMatch'
2962 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )
2963 //
2964 // The caseIgnoreMatch rule is an equality matching rule.
2965 //
2966 .oid = "2.5.13.2",
2967 .name = "caseIgnoreMatch",
2968 .desc = "caseIgnoreMatch",
2969 .type = LDAPSCHEMA_MATCHINGRULE,
2970 .def = "( 2.5.13.2 NAME 'caseIgnoreMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
2971 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
2972 .spec_type = LDAPSCHEMA_SPEC_RFC,
2973 .spec_name = "4517",
2974 .spec_section = "4.2.11",
2975 .spec_source = NULL,
2976 .spec_vendor = "IETF",
2977};
2978
2979
2980
2981{
2982 //
2983 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
2984 //
2985 // 4.2.12. caseIgnoreOrderingMatch
2986 //
2987 // The caseIgnoreOrderingMatch rule compares an assertion value of the
2988 // Directory String syntax to an attribute value of a syntax (e.g., the
2989 // Directory String, Printable String, Country String, or Telephone
2990 // Number syntax) whose corresponding ASN.1 type is DirectoryString or
2991 // one of its alternative string types.
2992 //
2993 // The rule evaluates to TRUE if and only if, in the code point
2994 // collation order, the prepared attribute value character string
2995 // appears earlier than the prepared assertion value character string;
2996 // i.e., the attribute value is "less than" the assertion value.
2997 //
2998 // In preparing the attribute value and assertion value for comparison,
2999 // characters are case folded in the Map preparation step, and only
3000 // Insignificant Space Handling is applied in the Insignificant
3001 // Character Handling step.
3002 //
3003 // The LDAP definition for the caseIgnoreOrderingMatch rule is:
3004 //
3005 // ( 2.5.13.3 NAME 'caseIgnoreOrderingMatch'
3006 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )
3007 //
3008 // The caseIgnoreOrderingMatch rule is an ordering matching rule.
3009 //
3010 .oid = "2.5.13.3",
3011 .name = "caseIgnoreOrderingMatch",
3012 .desc = "caseIgnoreOrderingMatch",
3013 .type = LDAPSCHEMA_MATCHINGRULE,
3014 .def = "( 2.5.13.3 NAME 'caseIgnoreOrderingMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
3015 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
3016 .spec_type = LDAPSCHEMA_SPEC_RFC,
3017 .spec_name = "4517",
3018 .spec_section = "4.2.12",
3019 .spec_source = NULL,
3020 .spec_vendor = "IETF",
3021};
3022
3023
3024
3025{
3026 //
3027 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
3028 //
3029 // 4.2.13. caseIgnoreSubstringsMatch
3030 //
3031 // The caseIgnoreSubstringsMatch rule compares an assertion value of the
3032 // Substring Assertion syntax to an attribute value of a syntax (e.g.,
3033 // the Directory String, Printable String, Country String, or Telephone
3034 // Number syntax) whose corresponding ASN.1 type is DirectoryString or
3035 // one of its alternative string types.
3036 //
3037 // The rule evaluates to TRUE if and only if (1) the prepared substrings
3038 // of the assertion value match disjoint portions of the prepared
3039 // attribute value character string in the order of the substrings in
3040 // the assertion value, (2) an <initial> substring, if present, matches
3041 // the beginning of the prepared attribute value character string, and
3042 // (3) a <final> substring, if present, matches the end of the prepared
3043 // attribute value character string. A prepared substring matches a
3044 // portion of the prepared attribute value character string if
3045 // corresponding characters have the same code point.
3046 //
3047 // In preparing the attribute value and assertion value substrings for
3048 // comparison, characters are case folded in the Map preparation step,
3049 // and only Insignificant Space Handling is applied in the Insignificant
3050 // Character Handling step.
3051 //
3052 // The LDAP definition for the caseIgnoreSubstringsMatch rule is:
3053 //
3054 // ( 2.5.13.4 NAME 'caseIgnoreSubstringsMatch'
3055 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )
3056 //
3057 // The caseIgnoreSubstringsMatch rule is a substrings matching rule.
3058 //
3059 .oid = "2.5.13.4",
3060 .name = "caseIgnoreSubstringsMatch",
3061 .desc = "caseIgnoreSubstringsMatch",
3062 .type = LDAPSCHEMA_MATCHINGRULE,
3063 .def = "( 2.5.13.4 NAME 'caseIgnoreSubstringsMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
3064 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
3065 .spec_type = LDAPSCHEMA_SPEC_RFC,
3066 .spec_name = "4517",
3067 .spec_section = "4.2.13",
3068 .spec_source = NULL,
3069 .spec_vendor = "IETF",
3070};
3071
3072
3073
3074{
3075 //
3076 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
3077 //
3078 // 4.2.14. directoryStringFirstComponentMatch
3079 //
3080 // The directoryStringFirstComponentMatch rule compares an assertion
3081 // value of the Directory String syntax to an attribute value of a
3082 // syntax whose corresponding ASN.1 type is a SEQUENCE with a mandatory
3083 // first component of the DirectoryString ASN.1 type.
3084 //
3085 // Note that the assertion syntax of this matching rule differs from the
3086 // attribute syntax of attributes for which this is the equality
3087 // matching rule.
3088 //
3089 // The rule evaluates to TRUE if and only if the assertion value matches
3090 // the first component of the attribute value using the rules of
3091 // caseIgnoreMatch.
3092 //
3093 // The LDAP definition for the directoryStringFirstComponentMatch
3094 // matching rule is:
3095 //
3096 // ( 2.5.13.31 NAME 'directoryStringFirstComponentMatch'
3097 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )
3098 //
3099 // The directoryStringFirstComponentMatch rule is an equality matching
3100 // rule. When using directoryStringFirstComponentMatch to compare two
3101 // attribute values (of an applicable syntax), an assertion value must
3102 // first be derived from one of the attribute values. An assertion
3103 // value can be derived from an attribute value by taking the first
3104 // component of that attribute value.
3105 //
3106 .oid = "2.5.13.31",
3107 .name = "directoryStringFirstComponentMatch",
3108 .desc = "directoryStringFirstComponentMatch",
3109 .type = LDAPSCHEMA_MATCHINGRULE,
3110 .def = "( 2.5.13.31 NAME 'directoryStringFirstComponentMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
3111 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
3112 .spec_type = LDAPSCHEMA_SPEC_RFC,
3113 .spec_name = "4517",
3114 .spec_section = "4.2.14",
3115 .spec_source = NULL,
3116 .spec_vendor = "IETF",
3117};
3118
3119
3120
3121{
3122 //
3123 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
3124 //
3125 // 4.2.15. distinguishedNameMatch
3126 //
3127 // The distinguishedNameMatch rule compares an assertion value of the DN
3128 // syntax to an attribute value of a syntax (e.g., the DN syntax) whose
3129 // corresponding ASN.1 type is DistinguishedName.
3130 //
3131 // The rule evaluates to TRUE if and only if the attribute value and the
3132 // assertion value have the same number of relative distinguished names
3133 // and corresponding relative distinguished names (by position) are the
3134 // same. A relative distinguished name (RDN) of the assertion value is
3135 // the same as an RDN of the attribute value if and only if they have
3136 // the same number of attribute value assertions and each attribute
3137 // value assertion (AVA) of the first RDN is the same as the AVA of the
3138 // second RDN with the same attribute type. The order of the AVAs is
3139 // not significant. Also note that a particular attribute type may
3140 // appear in at most one AVA in an RDN. Two AVAs with the same
3141 // attribute type are the same if their values are equal according to
3142 // the equality matching rule of the attribute type. If one or more of
3143 // the AVA comparisons evaluate to Undefined and the remaining AVA
3144 // comparisons return TRUE then the distinguishedNameMatch rule
3145 // evaluates to Undefined.
3146 //
3147 // The LDAP definition for the distinguishedNameMatch rule is:
3148 //
3149 // ( 2.5.13.1 NAME 'distinguishedNameMatch'
3150 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.12 )
3151 //
3152 // The distinguishedNameMatch rule is an equality matching rule.
3153 //
3154 .oid = "2.5.13.1",
3155 .name = "distinguishedNameMatch",
3156 .desc = "distinguishedNameMatch",
3157 .type = LDAPSCHEMA_MATCHINGRULE,
3158 .def = "( 2.5.13.1 NAME 'distinguishedNameMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.12 )",
3159 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
3160 .spec_type = LDAPSCHEMA_SPEC_RFC,
3161 .spec_name = "4517",
3162 .spec_section = "4.2.15",
3163 .spec_source = NULL,
3164 .spec_vendor = "IETF",
3165};
3166
3167
3168
3169{
3170 //
3171 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
3172 //
3173 // 4.2.16. generalizedTimeMatch
3174 //
3175 // The generalizedTimeMatch rule compares an assertion value of the
3176 // Generalized Time syntax to an attribute value of a syntax (e.g., the
3177 // Generalized Time syntax) whose corresponding ASN.1 type is
3178 // GeneralizedTime.
3179 //
3180 // The rule evaluates to TRUE if and only if the attribute value
3181 // represents the same universal coordinated time as the assertion
3182 // value. If a time is specified with the minutes or seconds absent,
3183 // then the number of minutes or seconds (respectively) is assumed to be
3184 // zero.
3185 //
3186 // The LDAP definition for the generalizedTimeMatch rule is:
3187 //
3188 // ( 2.5.13.27 NAME 'generalizedTimeMatch'
3189 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 )
3190 //
3191 // The generalizedTimeMatch rule is an equality matching rule.
3192 //
3193 .oid = "2.5.13.27",
3194 .name = "generalizedTimeMatch",
3195 .desc = "generalizedTimeMatch",
3196 .type = LDAPSCHEMA_MATCHINGRULE,
3197 .def = "( 2.5.13.27 NAME 'generalizedTimeMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 )",
3198 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
3199 .spec_type = LDAPSCHEMA_SPEC_RFC,
3200 .spec_name = "4517",
3201 .spec_section = "4.2.16",
3202 .spec_source = NULL,
3203 .spec_vendor = "IETF",
3204};
3205
3206
3207
3208{
3209 //
3210 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
3211 //
3212 // 4.2.17. generalizedTimeOrderingMatch
3213 //
3214 // The generalizedTimeOrderingMatch rule compares the time ordering of
3215 // an assertion value of the Generalized Time syntax to an attribute
3216 // value of a syntax (e.g., the Generalized Time syntax) whose
3217 // corresponding ASN.1 type is GeneralizedTime.
3218 //
3219 // The rule evaluates to TRUE if and only if the attribute value
3220 // represents a universal coordinated time that is earlier than the
3221 // universal coordinated time represented by the assertion value.
3222 //
3223 // The LDAP definition for the generalizedTimeOrderingMatch rule is:
3224 //
3225 // ( 2.5.13.28 NAME 'generalizedTimeOrderingMatch'
3226 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 )
3227 //
3228 // The generalizedTimeOrderingMatch rule is an ordering matching rule.
3229 //
3230 .oid = "2.5.13.28",
3231 .name = "generalizedTimeOrderingMatch",
3232 .desc = "generalizedTimeOrderingMatch",
3233 .type = LDAPSCHEMA_MATCHINGRULE,
3234 .def = "( 2.5.13.28 NAME 'generalizedTimeOrderingMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 )",
3235 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
3236 .spec_type = LDAPSCHEMA_SPEC_RFC,
3237 .spec_name = "4517",
3238 .spec_section = "4.2.17",
3239 .spec_source = NULL,
3240 .spec_vendor = "IETF",
3241};
3242
3243
3244
3245{
3246 //
3247 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
3248 //
3249 // 4.2.18. integerFirstComponentMatch
3250 //
3251 // The integerFirstComponentMatch rule compares an assertion value of
3252 // the Integer syntax to an attribute value of a syntax (e.g., the DIT
3253 // Structure Rule Description syntax) whose corresponding ASN.1 type is
3254 // a SEQUENCE with a mandatory first component of the INTEGER ASN.1
3255 // type.
3256 //
3257 // Note that the assertion syntax of this matching rule differs from the
3258 // attribute syntax of attributes for which this is the equality
3259 // matching rule.
3260 //
3261 // The rule evaluates to TRUE if and only if the assertion value and the
3262 // first component of the attribute value are the same integer value.
3263 //
3264 // The LDAP definition for the integerFirstComponentMatch matching rule
3265 // is:
3266 //
3267 // ( 2.5.13.29 NAME 'integerFirstComponentMatch'
3268 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 )
3269 //
3270 // The integerFirstComponentMatch rule is an equality matching rule.
3271 // When using integerFirstComponentMatch to compare two attribute values
3272 // (of an applicable syntax), an assertion value must first be derived
3273 // from one of the attribute values. An assertion value can be derived
3274 // from an attribute value by taking the first component of that
3275 // attribute value.
3276 //
3277 .oid = "2.5.13.29",
3278 .name = "integerFirstComponentMatch",
3279 .desc = "integerFirstComponentMatch",
3280 .type = LDAPSCHEMA_MATCHINGRULE,
3281 .def = "( 2.5.13.29 NAME 'integerFirstComponentMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 )",
3282 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
3283 .spec_type = LDAPSCHEMA_SPEC_RFC,
3284 .spec_name = "4517",
3285 .spec_section = "4.2.18",
3286 .spec_source = NULL,
3287 .spec_vendor = "IETF",
3288};
3289
3290
3291
3292{
3293 //
3294 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
3295 //
3296 // 4.2.19. integerMatch
3297 //
3298 // The integerMatch rule compares an assertion value of the Integer
3299 // syntax to an attribute value of a syntax (e.g., the Integer syntax)
3300 // whose corresponding ASN.1 type is INTEGER.
3301 //
3302 // The rule evaluates to TRUE if and only if the attribute value and the
3303 // assertion value are the same integer value.
3304 //
3305 // The LDAP definition for the integerMatch matching rule is:
3306 //
3307 // ( 2.5.13.14 NAME 'integerMatch'
3308 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 )
3309 //
3310 // The integerMatch rule is an equality matching rule.
3311 //
3312 .oid = "2.5.13.14",
3313 .name = "integerMatch",
3314 .desc = "integerMatch",
3315 .type = LDAPSCHEMA_MATCHINGRULE,
3316 .def = "( 2.5.13.14 NAME 'integerMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 )",
3317 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
3318 .spec_type = LDAPSCHEMA_SPEC_RFC,
3319 .spec_name = "4517",
3320 .spec_section = "4.2.19",
3321 .spec_source = NULL,
3322 .spec_vendor = "IETF",
3323};
3324
3325
3326
3327{
3328 //
3329 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
3330 //
3331 // 4.2.20. integerOrderingMatch
3332 //
3333 // The integerOrderingMatch rule compares an assertion value of the
3334 // Integer syntax to an attribute value of a syntax (e.g., the Integer
3335 // syntax) whose corresponding ASN.1 type is INTEGER.
3336 //
3337 // The rule evaluates to TRUE if and only if the integer value of the
3338 // attribute value is less than the integer value of the assertion
3339 // value.
3340 //
3341 // The LDAP definition for the integerOrderingMatch matching rule is:
3342 //
3343 // ( 2.5.13.15 NAME 'integerOrderingMatch'
3344 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 )
3345 //
3346 // The integerOrderingMatch rule is an ordering matching rule.
3347 //
3348 .oid = "2.5.13.15",
3349 .name = "integerOrderingMatch",
3350 .desc = "integerOrderingMatch",
3351 .type = LDAPSCHEMA_MATCHINGRULE,
3352 .def = "( 2.5.13.15 NAME 'integerOrderingMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 )",
3353 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
3354 .spec_type = LDAPSCHEMA_SPEC_RFC,
3355 .spec_name = "4517",
3356 .spec_section = "4.2.20",
3357 .spec_source = NULL,
3358 .spec_vendor = "IETF",
3359};
3360
3361
3362
3363{
3364 //
3365 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
3366 //
3367 // 4.2.21. keywordMatch
3368 //
3369 // The keywordMatch rule compares an assertion value of the Directory
3370 // String syntax to an attribute value of a syntax (e.g., the Directory
3371 // String syntax) whose corresponding ASN.1 type is DirectoryString.
3372 //
3373 // The rule evaluates to TRUE if and only if the assertion value
3374 // character string matches any keyword in the attribute value. The
3375 // identification of keywords in the attribute value and the exactness
3376 // of the match are both implementation specific.
3377 //
3378 // The LDAP definition for the keywordMatch rule is:
3379 //
3380 // ( 2.5.13.33 NAME 'keywordMatch'
3381 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )
3382 //
3383 .oid = "2.5.13.33",
3384 .name = "integerOrderingMatch",
3385 .desc = "integerOrderingMatch",
3386 .type = LDAPSCHEMA_MATCHINGRULE,
3387 .def = "( 2.5.13.33 NAME 'keywordMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
3388 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
3389 .spec_type = LDAPSCHEMA_SPEC_RFC,
3390 .spec_name = "4517",
3391 .spec_section = "4.2.21",
3392 .spec_source = NULL,
3393 .spec_vendor = "IETF",
3394};
3395
3396
3397
3398{
3399 //
3400 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
3401 //
3402 // 4.2.22. numericStringMatch
3403 //
3404 // The numericStringMatch rule compares an assertion value of the
3405 // Numeric String syntax to an attribute value of a syntax (e.g., the
3406 // Numeric String syntax) whose corresponding ASN.1 type is
3407 // NumericString.
3408 //
3409 // The rule evaluates to TRUE if and only if the prepared attribute
3410 // value character string and the prepared assertion value character
3411 // string have the same number of characters and corresponding
3412 // characters have the same code point.
3413 //
3414 // In preparing the attribute value and assertion value for comparison,
3415 // characters are not case folded in the Map preparation step, and only
3416 // numericString Insignificant Character Handling is applied in the
3417 // Insignificant Character Handling step.
3418 //
3419 // The LDAP definition for the numericStringMatch matching rule is:
3420 //
3421 // ( 2.5.13.8 NAME 'numericStringMatch'
3422 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.36 )
3423 //
3424 // The numericStringMatch rule is an equality matching rule.
3425 //
3426 .oid = "2.5.13.8",
3427 .name = "numericStringMatch",
3428 .desc = "numericStringMatch",
3429 .type = LDAPSCHEMA_MATCHINGRULE,
3430 .def = "( 2.5.13.8 NAME 'numericStringMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.36 )",
3431 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
3432 .spec_type = LDAPSCHEMA_SPEC_RFC,
3433 .spec_name = "4517",
3434 .spec_section = "4.2.22",
3435 .spec_source = NULL,
3436 .spec_vendor = "IETF",
3437};
3438
3439
3440
3441{
3442 //
3443 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
3444 //
3445 // 4.2.23. numericStringOrderingMatch
3446 //
3447 // The numericStringOrderingMatch rule compares an assertion value of
3448 // the Numeric String syntax to an attribute value of a syntax (e.g.,
3449 // the Numeric String syntax) whose corresponding ASN.1 type is
3450 // NumericString.
3451 //
3452 // The rule evaluates to TRUE if and only if, in the code point
3453 // collation order, the prepared attribute value character string
3454 // appears earlier than the prepared assertion value character string;
3455 // i.e., the attribute value is "less than" the assertion value.
3456 //
3457 // In preparing the attribute value and assertion value for comparison,
3458 // characters are not case folded in the Map preparation step, and only
3459 // numericString Insignificant Character Handling is applied in the
3460 // Insignificant Character Handling step.
3461 //
3462 // The rule is identical to the caseIgnoreOrderingMatch rule except that
3463 // all space characters are skipped during comparison (case is
3464 // irrelevant as the characters are numeric).
3465 //
3466 // The LDAP definition for the numericStringOrderingMatch matching rule
3467 // is:
3468 //
3469 // ( 2.5.13.9 NAME 'numericStringOrderingMatch'
3470 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.36 )
3471 //
3472 // The numericStringOrderingMatch rule is an ordering matching rule.
3473 //
3474 .oid = "2.5.13.9",
3475 .name = "numericStringOrderingMatch",
3476 .desc = "numericStringOrderingMatch",
3477 .type = LDAPSCHEMA_MATCHINGRULE,
3478 .def = "( 2.5.13.9 NAME 'numericStringOrderingMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.36 )",
3479 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
3480 .spec_type = LDAPSCHEMA_SPEC_RFC,
3481 .spec_name = "4517",
3482 .spec_section = "4.2.23",
3483 .spec_source = NULL,
3484 .spec_vendor = "IETF",
3485};
3486
3487
3488
3489{
3490 //
3491 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
3492 //
3493 // 4.2.24. numericStringSubstringsMatch
3494 //
3495 // The numericStringSubstringsMatch rule compares an assertion value of
3496 // the Substring Assertion syntax to an attribute value of a syntax
3497 // (e.g., the Numeric String syntax) whose corresponding ASN.1 type is
3498 // NumericString.
3499 //
3500 // The rule evaluates to TRUE if and only if (1) the prepared substrings
3501 // of the assertion value match disjoint portions of the prepared
3502 // attribute value character string in the order of the substrings in
3503 // the assertion value, (2) an <initial> substring, if present, matches
3504 // the beginning of the prepared attribute value character string, and
3505 // (3) a <final> substring, if present, matches the end of the prepared
3506 // attribute value character string. A prepared substring matches a
3507 // portion of the prepared attribute value character string if
3508 // corresponding characters have the same code point.
3509 //
3510 // In preparing the attribute value and assertion value for comparison,
3511 // characters are not case folded in the Map preparation step, and only
3512 // numericString Insignificant Character Handling is applied in the
3513 // Insignificant Character Handling step.
3514 //
3515 // The LDAP definition for the numericStringSubstringsMatch matching
3516 // rule is:
3517 //
3518 // ( 2.5.13.10 NAME 'numericStringSubstringsMatch'
3519 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )
3520 //
3521 // The numericStringSubstringsMatch rule is a substrings matching rule.
3522 //
3523 .oid = "2.5.13.10",
3524 .name = "numericStringSubstringsMatch",
3525 .desc = "numericStringSubstringsMatch",
3526 .type = LDAPSCHEMA_MATCHINGRULE,
3527 .def = "( 2.5.13.10 NAME 'numericStringSubstringsMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
3528 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
3529 .spec_type = LDAPSCHEMA_SPEC_RFC,
3530 .spec_name = "4517",
3531 .spec_section = "4.2.24",
3532 .spec_source = NULL,
3533 .spec_vendor = "IETF",
3534};
3535
3536
3537
3538{
3539 //
3540 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
3541 //
3542 // 4.2.25. objectIdentifierFirstComponentMatch
3543 //
3544 // The objectIdentifierFirstComponentMatch rule compares an assertion
3545 // value of the OID syntax to an attribute value of a syntax (e.g., the
3546 // Attribute Type Description, DIT Content Rule Description, LDAP Syntax
3547 // Description, Matching Rule Description, Matching Rule Use
3548 // Description, Name Form Description, or Object Class Description
3549 // syntax) whose corresponding ASN.1 type is a SEQUENCE with a mandatory
3550 // first component of the OBJECT IDENTIFIER ASN.1 type.
3551 //
3552 // Note that the assertion syntax of this matching rule differs from the
3553 // attribute syntax of attributes for which this is the equality
3554 // matching rule.
3555 //
3556 // The rule evaluates to TRUE if and only if the assertion value matches
3557 // the first component of the attribute value using the rules of
3558 // objectIdentifierMatch.
3559 //
3560 // The LDAP definition for the objectIdentifierFirstComponentMatch
3561 // matching rule is:
3562 //
3563 // ( 2.5.13.30 NAME 'objectIdentifierFirstComponentMatch'
3564 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.38 )
3565 //
3566 // The objectIdentifierFirstComponentMatch rule is an equality matching
3567 // rule. When using objectIdentifierFirstComponentMatch to compare two
3568 // attribute values (of an applicable syntax), an assertion value must
3569 // first be derived from one of the attribute values. An assertion
3570 // value can be derived from an attribute value by taking the first
3571 // component of that attribute value.
3572 //
3573 .oid = "2.5.13.30",
3574 .name = "objectIdentifierFirstComponentMatch",
3575 .desc = "objectIdentifierFirstComponentMatch",
3576 .type = LDAPSCHEMA_MATCHINGRULE,
3577 .def = "( 2.5.13.30 NAME 'objectIdentifierFirstComponentMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.38 )",
3578 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
3579 .spec_type = LDAPSCHEMA_SPEC_RFC,
3580 .spec_name = "4517",
3581 .spec_section = "4.2.25",
3582 .spec_source = NULL,
3583 .spec_vendor = "IETF",
3584};
3585
3586
3587
3588{
3589 //
3590 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
3591 //
3592 // 4.2.26. objectIdentifierMatch
3593 //
3594 // The objectIdentifierMatch rule compares an assertion value of the OID
3595 // syntax to an attribute value of a syntax (e.g., the OID syntax) whose
3596 // corresponding ASN.1 type is OBJECT IDENTIFIER.
3597 //
3598 // The rule evaluates to TRUE if and only if the assertion value and the
3599 // attribute value represent the same object identifier; that is, the
3600 // same sequence of integers, whether represented explicitly in the
3601 // <numericoid> form of <oid> or implicitly in the <descr> form (see
3602 // [RFC4512]).
3603 //
3604 // If an LDAP client supplies an assertion value in the <descr> form and
3605 // the chosen descriptor is not recognized by the server, then the
3606 // objectIdentifierMatch rule evaluates to Undefined.
3607 //
3608 // The LDAP definition for the objectIdentifierMatch matching rule is:
3609 //
3610 // ( 2.5.13.0 NAME 'objectIdentifierMatch'
3611 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.38 )
3612 //
3613 // The objectIdentifierMatch rule is an equality matching rule.
3614 //
3615 .oid = "2.5.13.0",
3616 .name = "objectIdentifierMatch",
3617 .desc = "objectIdentifierMatch",
3618 .type = LDAPSCHEMA_MATCHINGRULE,
3619 .def = "( 2.5.13.0 NAME 'objectIdentifierMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.38 )",
3620 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
3621 .spec_type = LDAPSCHEMA_SPEC_RFC,
3622 .spec_name = "4517",
3623 .spec_section = "4.2.26",
3624 .spec_source = NULL,
3625 .spec_vendor = "IETF",
3626};
3627
3628
3629
3630{
3631 //
3632 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
3633 //
3634 // 4.2.27. octetStringMatch
3635 //
3636 // The octetStringMatch rule compares an assertion value of the Octet
3637 // String syntax to an attribute value of a syntax (e.g., the Octet
3638 // String or JPEG syntax) whose corresponding ASN.1 type is the OCTET
3639 // STRING ASN.1 type.
3640 //
3641 // The rule evaluates to TRUE if and only if the attribute value and the
3642 // assertion value are the same length and corresponding octets (by
3643 // position) are the same.
3644 //
3645 // The LDAP definition for the octetStringMatch matching rule is:
3646 //
3647 // ( 2.5.13.17 NAME 'octetStringMatch'
3648 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 )
3649 //
3650 // The octetStringMatch rule is an equality matching rule.
3651 //
3652 .oid = "2.5.13.17",
3653 .name = "octetStringMatch",
3654 .desc = "octetStringMatch",
3655 .type = LDAPSCHEMA_MATCHINGRULE,
3656 .def = "( 2.5.13.17 NAME 'octetStringMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 )",
3657 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
3658 .spec_type = LDAPSCHEMA_SPEC_RFC,
3659 .spec_name = "4517",
3660 .spec_section = "4.2.27",
3661 .spec_source = NULL,
3662 .spec_vendor = "IETF",
3663};
3664
3665
3666
3667{
3668 //
3669 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
3670 //
3671 // 4.2.28. octetStringOrderingMatch
3672 //
3673 // The octetStringOrderingMatch rule compares an assertion value of the
3674 // Octet String syntax to an attribute value of a syntax (e.g., the
3675 // Octet String or JPEG syntax) whose corresponding ASN.1 type is the
3676 // OCTET STRING ASN.1 type.
3677 //
3678 // The rule evaluates to TRUE if and only if the attribute value appears
3679 // earlier in the collation order than the assertion value. The rule
3680 // compares octet strings from the first octet to the last octet, and
3681 // from the most significant bit to the least significant bit within the
3682 // octet. The first occurrence of a different bit determines the
3683 // ordering of the strings. A zero bit precedes a one bit. If the
3684 // strings contain different numbers of octets but the longer string is
3685 // identical to the shorter string up to the length of the shorter
3686 // string, then the shorter string precedes the longer string.
3687 //
3688 // The LDAP definition for the octetStringOrderingMatch matching rule
3689 // is:
3690 //
3691 // ( 2.5.13.18 NAME 'octetStringOrderingMatch'
3692 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 )
3693 //
3694 // The octetStringOrderingMatch rule is an ordering matching rule.
3695 //
3696 .oid = "2.5.13.18",
3697 .name = "octetStringOrderingMatch",
3698 .desc = "octetStringOrderingMatch",
3699 .type = LDAPSCHEMA_MATCHINGRULE,
3700 .def = "( 2.5.13.18 NAME 'octetStringOrderingMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 )",
3701 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
3702 .spec_type = LDAPSCHEMA_SPEC_RFC,
3703 .spec_name = "4517",
3704 .spec_section = "4.2.28",
3705 .spec_source = NULL,
3706 .spec_vendor = "IETF",
3707};
3708
3709
3710
3711{
3712 //
3713 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
3714 //
3715 // 4.2.29. telephoneNumberMatch
3716 //
3717 // The telephoneNumberMatch rule compares an assertion value of the
3718 // Telephone Number syntax to an attribute value of a syntax (e.g., the
3719 // Telephone Number syntax) whose corresponding ASN.1 type is a
3720 // PrintableString representing a telephone number.
3721 //
3722 // The rule evaluates to TRUE if and only if the prepared attribute
3723 // value character string and the prepared assertion value character
3724 // string have the same number of characters and corresponding
3725 // characters have the same code point.
3726 //
3727 // In preparing the attribute value and assertion value for comparison,
3728 // characters are case folded in the Map preparation step, and only
3729 // telephoneNumber Insignificant Character Handling is applied in the
3730 // Insignificant Character Handling step.
3731 //
3732 // The LDAP definition for the telephoneNumberMatch matching rule is:
3733 //
3734 // ( 2.5.13.20 NAME 'telephoneNumberMatch'
3735 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.50 )
3736 //
3737 // The telephoneNumberMatch rule is an equality matching rule.
3738 //
3739 .oid = "2.5.13.20",
3740 .name = "telephoneNumberMatch",
3741 .desc = "telephoneNumberMatch",
3742 .type = LDAPSCHEMA_MATCHINGRULE,
3743 .def = "( 2.5.13.20 NAME 'telephoneNumberMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.50 )",
3744 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
3745 .spec_type = LDAPSCHEMA_SPEC_RFC,
3746 .spec_name = "4517",
3747 .spec_section = "4.2.29",
3748 .spec_source = NULL,
3749 .spec_vendor = "IETF",
3750};
3751
3752
3753
3754{
3755 //
3756 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
3757 //
3758 // 4.2.30. telephoneNumberSubstringsMatch
3759 //
3760 // The telephoneNumberSubstringsMatch rule compares an assertion value
3761 // of the Substring Assertion syntax to an attribute value of a syntax
3762 // (e.g., the Telephone Number syntax) whose corresponding ASN.1 type is
3763 // a PrintableString representing a telephone number.
3764 //
3765 // The rule evaluates to TRUE if and only if (1) the prepared substrings
3766 // of the assertion value match disjoint portions of the prepared
3767 // attribute value character string in the order of the substrings in
3768 // the assertion value, (2) an <initial> substring, if present, matches
3769 // the beginning of the prepared attribute value character string, and
3770 // (3) a <final> substring, if present, matches the end of the prepared
3771 // attribute value character string. A prepared substring matches a
3772 // portion of the prepared attribute value character string if
3773 // corresponding characters have the same code point.
3774 //
3775 // In preparing the attribute value and assertion value substrings for
3776 // comparison, characters are case folded in the Map preparation step,
3777 // and only telephoneNumber Insignificant Character Handling is applied
3778 // in the Insignificant Character Handling step.
3779 //
3780 // The LDAP definition for the telephoneNumberSubstringsMatch matching
3781 // rule is:
3782 //
3783 // ( 2.5.13.21 NAME 'telephoneNumberSubstringsMatch'
3784 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )
3785 //
3786 // The telephoneNumberSubstringsMatch rule is a substrings matching
3787 // rule.
3788 //
3789 .oid = "2.5.13.21",
3790 .name = "telephoneNumberSubstringsMatch",
3791 .desc = "telephoneNumberSubstringsMatch",
3792 .type = LDAPSCHEMA_MATCHINGRULE,
3793 .def = "( 2.5.13.21 NAME 'telephoneNumberSubstringsMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
3794 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
3795 .spec_type = LDAPSCHEMA_SPEC_RFC,
3796 .spec_name = "4517",
3797 .spec_section = "4.2.30",
3798 .spec_source = NULL,
3799 .spec_vendor = "IETF",
3800};
3801
3802
3803
3804{
3805 //
3806 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
3807 //
3808 // 4.2.31. uniqueMemberMatch
3809 //
3810 // The uniqueMemberMatch rule compares an assertion value of the Name
3811 // And Optional UID syntax to an attribute value of a syntax (e.g., the
3812 // Name And Optional UID syntax) whose corresponding ASN.1 type is
3813 // NameAndOptionalUID.
3814 //
3815 // The rule evaluates to TRUE if and only if the <distinguishedName>
3816 // components of the assertion value and attribute value match according
3817 // to the distinguishedNameMatch rule and either, (1) the <BitString>
3818 // component is absent from both the attribute value and assertion
3819 // value, or (2) the <BitString> component is present in both the
3820 // attribute value and the assertion value and the <BitString> component
3821 // of the assertion value matches the <BitString> component of the
3822 // attribute value according to the bitStringMatch rule.
3823 //
3824 // Note that this matching rule has been altered from its description in
3825 // X.520 [X.520] in order to make the matching rule commutative. Server
3826 // implementors should consider using the original X.520 semantics
3827 // (where the matching was less exact) for approximate matching of
3828 // attributes with uniqueMemberMatch as the equality matching rule.
3829 //
3830 // The LDAP definition for the uniqueMemberMatch matching rule is:
3831 //
3832 // ( 2.5.13.23 NAME 'uniqueMemberMatch'
3833 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.34 )
3834 //
3835 // The uniqueMemberMatch rule is an equality matching rule.
3836 //
3837 .oid = "2.5.13.23",
3838 .name = "uniqueMemberMatch",
3839 .desc = "uniqueMemberMatch",
3840 .type = LDAPSCHEMA_MATCHINGRULE,
3841 .def = "( 2.5.13.23 NAME 'uniqueMemberMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.34 )",
3842 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
3843 .spec_type = LDAPSCHEMA_SPEC_RFC,
3844 .spec_name = "4517",
3845 .spec_section = "4.2.31",
3846 .spec_source = NULL,
3847 .spec_vendor = "IETF",
3848};
3849
3850
3851
3852{
3853 //
3854 // RFC 4517 LDAP: Syntaxes and Matching Rules June 2006
3855 //
3856 // 4.2.32. wordMatch
3857 //
3858 // The wordMatch rule compares an assertion value of the Directory
3859 // String syntax to an attribute value of a syntax (e.g., the Directory
3860 // String syntax) whose corresponding ASN.1 type is DirectoryString.
3861 //
3862 // The rule evaluates to TRUE if and only if the assertion value word
3863 // matches, according to the semantics of caseIgnoreMatch, any word in
3864 // the attribute value. The precise definition of a word is
3865 // implementation specific.
3866 //
3867 // The LDAP definition for the wordMatch rule is:
3868 //
3869 // ( 2.5.13.32 NAME 'wordMatch'
3870 // SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )
3871 //
3872 .oid = "2.5.13.32",
3873 .name = "wordMatch",
3874 .desc = "wordMatch",
3875 .type = LDAPSCHEMA_MATCHINGRULE,
3876 .def = "( 2.5.13.32 NAME 'wordMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
3877 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules",
3878 .spec_type = LDAPSCHEMA_SPEC_RFC,
3879 .spec_name = "4517",
3880 .spec_section = "4.2.32",
3881 .spec_source = NULL,
3882 .spec_vendor = "IETF",
3883};
3884
3885
3886// end of OID spec file
diff --git a/doc/oidspecs/template.oidspec b/doc/oidspecs/template.oidspec
new file mode 100644
index 0000000..5e0b905
--- /dev/null
+++ b/doc/oidspecs/template.oidspec
@@ -0,0 +1,31 @@
1{
2 // Documentation regarding OID described in OID specification (i.e. copy
3 // of relevent documentation) which should not be compiled into
4 // libldapschema.la. Comments are cheap, please be detailed.
5 //
6 .oid = "1.3.6.1.4.1.1466.115.121.1.6", // OID being described
7 .name = "BitString", // One work name of OID
8 .desc = "Bit String", // short description of OID
9 .flags = LDAPSCHEMA_O_READABLE, // relevant ldapschema flags from ldapschema.h
10 .type = LDAPSCHEMA_SYNTAX, // OID type (i.e. syntax, matching rule, etc)
11 .class = LDAPSCHEMA_CLASS_ASCII, // data class (i.e. utf8, integer, image, etc)
12 .def = "( 1.3.6.1.4.1.1466.115.121.1.6 DESC 'Bit String' )", // official definition of OID
13 .abnf = "BitString = SQUOTE *binary-digit SQUOTE \"B\"\n" // if a syntax, the syntax's ABNF
14 "SQUOTE = %x27 ; single quote (\"'\")\n"
15 "binary-digit = \"0\" / \"1\"\n",
16 .re_posix = "^('[01]{1,}'B)$", // POSIX regex equivalent of ABNF
17 .re_pcre = "^('[01]+'B)$", // PCRE equivalent of ABNF
18 .spec = "RFC 4517: LDAP: Syntaxes and Matching Rules", // name of specification which defines/declares OID
19 .spec_type = LDAPSCHEMA_SPEC_RFC, // type of specification
20 .spec_name = "4517", // short name of specification
21 .spec_section = "3.3.2", // section of specification which defines/declares OID
22 .spec_source = NULL, // URL of specification if not derivable from .spec_type
23 .spec_vendor = "IETF", // Vendor/author of spec
24 .examples = (const char *[])
25 {
26 "'0101111101'B",
27 NULL,
28 },
29};
30
31