![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to das-enc.py CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / dsap / x500as|
Return to das-enc.py CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / dsap / x500as |
1.1 root 1: -- das-enc.py - manually augmented DirectoryAbstractService module
2:
3: -- $Header: /f/osi/dsap/x500as/RCS/das-enc.py,v 7.0 89/11/23 21:50:14 mrose Rel $
4: --
5: --
6: -- $Log: das-enc.py,v $
7: -- Revision 7.0 89/11/23 21:50:14 mrose
8: -- Release 6.0
9: --
10:
11: --
12: -- NOTICE
13: --
14: -- Acquisition, use, and distribution of this module and related
15: -- materials are subject to the restrictions of a license agreement.
16: -- Consult the Preface in the User's Manual for the full terms of
17: -- this agreement.
18: --
19: --
20:
21:
22: DAS
23: {
24: joint-iso-ccitt
25: ds(5)
26: modules(1)
27: directoryAbstractService(2)
28: }
29:
30: DEFINITIONS ::=
31:
32: %{
33: #include "quipu/util.h"
34: #include "quipu/entry.h"
35: #include "quipu/common.h"
36:
37: extern LLog * log_dsap;
38:
39: #define encode_UNIV_UTCTime build_UNIV_UTCTime
40: %}
41:
42: PREFIXES encode decode print
43:
44: BEGIN
45:
46: -- EXPORTS
47: -- DirectoryBindArgument ,
48: -- ReadArgument ,
49: -- ReadResult ,
50: -- AbandonArgument ,
51: -- AbandonResult ,
52: -- CompareArgument ,
53: -- CompareResult ,
54: -- ListArgument ,
55: -- ListResult ,
56: -- SearchArgument ,
57: -- SearchResult ,
58: -- AddEntryArgument ,
59: -- AddEntryResult ,
60: -- RemoveEntryArgument ,
61: -- RemoveEntryResult ,
62: -- ModifyEntryArgument ,
63: -- ModifyEntryResult ,
64: -- ModifyRDNArgument ,
65: -- ModifyRDNResult ,
66: -- AbandonFailedParm ,
67: -- AttributeErrorParm ,
68: -- NameErrorParm ,
69: -- ReferralParm ,
70: -- SecurityErrorParm ,
71: -- ServiceErrorParm ,
72: -- UpdateErrorParm;
73:
74: IMPORTS
75: Attribute ,
76: AttributeType ,
77: AttributeValue ,
78: AttributeValueAssertion ,
79: DistinguishedName ,
80: Name ,
81: RelativeDistinguishedName
82: FROM IF
83: {
84: joint-iso-ccitt
85: ds(5)
86: modules(1)
87: informationFramework(1)
88: }
89:
90: OperationProgress ,
91: ContinuationReference ,
92: InvokeID
93: FROM DO
94: {
95: joint-iso-ccitt
96: ds(5)
97: modules(1)
98: distributedOperations(3)
99: }
100:
101: Certificate ,
102: CertificationPath ,
103: AlgorithmIdentifier
104: FROM AF
105: {
106: joint-iso-ccitt
107: ds(5)
108: modules(1)
109: authenticationFramework(7)
110: };
111:
112: ENCODER encode
113:
114: SimpleCredentials [[P struct ds_bind_arg *]]
115: %{
116: %}
117: ::=
118: %{
119: DLOG(log_dsap, LLOG_TRACE, ("About to encode SimpleCredentials (DAS)"));
120: %}
121: SEQUENCE
122: {
123: name
124: [0] DistinguishedName [[p parm->dba_dn]]
125: %{
126: %} ,
127: validity
128: [1] SET
129: %{
130: %}
131: {
132: time1
133: [0] UTCTime [[s parm -> dba_time1]]
134: %{
135: %} OPTIONAL <<parm -> dba_time1>> ,
136: time2
137: [1] UTCTime [[s parm -> dba_time2]]
138: %{
139: %} OPTIONAL <<parm -> dba_time2>> ,
140: random1
141: [2] BIT STRING [[x parm->dba_r1.value $ parm->dba_r1.n_bits]]
142: %{
143: %} OPTIONAL <<parm->dba_r1.value != NULLCP>> ,
144: random2
145: [3] BIT STRING [[x parm->dba_r2.value $ parm->dba_r2.n_bits]]
146: %{
147: %} OPTIONAL <<parm->dba_r2.value != NULLCP>>
148: }
149: %{
150: %} OPTIONAL <<parm -> dba_auth_type > DBA_AUTH_SIMPLE>> ,
151: password
152: [2] OCTET STRING [[o parm->dba_passwd $ parm->dba_passwd_len]]
153: %{
154: %}
155: OPTIONAL <<parm->dba_auth_type != DBA_AUTH_NONE>>
156: }
157: %{
158: DLOG(log_dsap, LLOG_TRACE, ("Done encode SimpleCredentials (DAS)"));
159: %}
160:
161: TokenToSign [[P struct ds_bind_arg *]]
162: %{
163: %}
164: ::=
165: %{
166: DLOG(log_dsap, LLOG_TRACE, ("About to encode TokenToSign (DAS)"));
167: %}
168: SEQUENCE
169: {
170: algorithm
171: [0] AlgorithmIdentifier [[p &(parm->dba_sig->alg)]],
172: name
173: [1] DistinguishedName [[p parm->dba_dn]] ,
174: time
175: [2] UTCTime [[s parm->dba_time1]],
176: random
177: [3] BIT STRING [[x parm->dba_r1.value $ parm->dba_r1.n_bits]]
178: }
179: %{
180: DLOG(log_dsap, LLOG_TRACE, ("Done encode TokenToSign (DAS)"));
181: %}
182:
183: Token [[P struct ds_bind_arg *]]
184: ::=
185: %{
186: DLOG(log_dsap, LLOG_TRACE, ("About to encode Token (DAS)"));
187: %}
188: SEQUENCE
189: {
190: TokenToSign [[p parm]],
191: AlgorithmIdentifier [[p &(parm->dba_sig->alg)]],
192: BIT STRING [[x parm->dba_sig->encrypted $ parm->dba_sig->n_bits]]
193: }
194: %{
195: DLOG(log_dsap, LLOG_TRACE, ("Done encode Token (DAS)"));
196: %}
197:
198: StrongCredentials [[P struct ds_bind_arg *]]
199: ::=
200: %{
201: DLOG(log_dsap, LLOG_TRACE, ("About to encode StrongCredentials (DAS)"));
202: %}
203: SET
204: {
205: certificationPath
206: [0] CertificationPath [[p parm->dba_cpath]]
207: OPTIONAL <<parm->dba_cpath>>,
208: bindToken
209: [1] Token [[p parm]]
210: }
211: %{
212: DLOG(log_dsap, LLOG_TRACE, ("Done encode StrongCredentials (DAS)"));
213: %}
214:
215: Credentials [[P struct ds_bind_arg *]]
216: %{
217: %}
218: ::=
219: %{
220: DLOG(log_dsap, LLOG_TRACE, ("About to encode Credentials (DAS)"));
221: %}
222: CHOICE
223: <<(parm->dba_auth_type == DBA_AUTH_STRONG)?2:1>>
224: {
225: simple
226: [0] SimpleCredentials [[p parm]]
227: %{
228: %} ,
229: strong
230: [1] StrongCredentials [[p parm]]
231: %{
232: %} ,
233: externalProcedure
234: [2] EXTERNAL
235: }
236: %{
237: DLOG(log_dsap, LLOG_TRACE, ("Done encode Credentials (DAS)"));
238: %}
239:
240: Versions [[P int]]
241: %{
242: int ver_len = 1;
243: char *ver_bits = int2strb(parm,ver_len);
244: %}
245: ::=
246: %{
247: DLOG(log_dsap, LLOG_TRACE, ("About to encode Versions (DAS)"));
248: %}
249: BIT STRING [[x ver_bits $ ver_len]]
250: {
251: v1988(0)
252: }
253: %{
254: DLOG(log_dsap, LLOG_TRACE, ("Done encode Versions (DAS)"));
255: %}
256:
257: SecurityProblem [[P int]]
258: %{
259: %}
260: ::=
261: %{
262: DLOG(log_dsap, LLOG_TRACE, ("About to encode SecurityProblem (DAS)"));
263: %}
264: INTEGER [[i parm]]
265: {
266: inappropriateAuthentication(1) ,
267: invalidCredentials(2) ,
268: insufficientAccessRights(3) ,
269: invalidSignature(4) ,
270: protectionRequired(5) ,
271: noInformation(6)
272: }
273: %{
274: DLOG(log_dsap, LLOG_TRACE, ("Done encode SecurityProblem (DAS)"));
275: %}
276:
277: ServiceProblem [[P int]]
278: %{
279: %}
280: ::=
281: %{
282: DLOG(log_dsap, LLOG_TRACE, ("About to encode ServiceProblem (DAS)"));
283: %}
284: INTEGER [[i parm]]
285: {
286: busy(1) ,
287: unavailable(2) ,
288: unwillingToPerform(3) ,
289: chainingRequired(4) ,
290: unableToProceed(5) ,
291: invalidReference(6) ,
292: timeLimitExceeded(7) ,
293: administrativeLimitExceeded(8) ,
294: loopDetected(9) ,
295: unavailableCriticalExtension(10) ,
296: outOfScope(11) ,
297: ditError(12)
298: }
299: %{
300: DLOG(log_dsap, LLOG_TRACE, ("Done encode ServiceProblem (DAS)"));
301: %}
302:
303: EntryInformationSelection [[P struct entryinfoselection *]]
304: %{
305: Attr_Sequence attr_temp;
306: %}
307: ::=
308: %{
309: DLOG(log_dsap, LLOG_TRACE, ("About to encode EntryInformationSelection (DAS)"));
310: %}
311: SET
312: {
313: attributeTypes
314: CHOICE
315: <<(parm->eis_allattributes ? 1 : 2)>>
316: {
317: allAttributes
318: [0] NULL ,
319: select
320: [1] SET OF
321: %{
322: %}
323: <<attr_temp=parm->eis_select;attr_temp!=NULLATTR;attr_temp=attr_temp->attr_link>>
324: AttributeType [[p attr_temp->attr_type]]
325: %{
326: %}
327: %{
328: %}
329: }
330: %{
331: %}
332: -- DEFAULT allAttributes NULL <<parm->eis_allattributes != TRUE>> ,
333: OPTIONAL <<parm->eis_allattributes != TRUE>> ,
334: infoTypes
335: [2] INTEGER [[i parm->eis_infotypes]]
336: {
337: attributeTypesOnly(0) ,
338: attributeTypesAndValues(1)
339: }
340: %{
341: %}
342: -- DEFAULT attributeTypesAndValues <<parm->eis_infotypes != EIS_ATTRIBUTESANDVALUES>>
343: OPTIONAL <<parm->eis_infotypes != EIS_ATTRIBUTESANDVALUES>>
344: }
345: %{
346: DLOG(log_dsap, LLOG_TRACE, ("Done encode EntryInformationSelection (DAS)"));
347: %}
348:
349: ServiceControls [[P struct svccontrol *]]
350: %{
351: int opt_len = 5;
352: char *opt_bits;
353: %}
354: ::=
355: %{
356: DLOG(log_dsap, LLOG_TRACE, ("About to encode ServiceControls (DAS)"));
357: opt_bits = int2strb(parm->svc_options,opt_len);
358: %}
359: SET
360: {
361: options
362: [0] BIT STRING [[x opt_bits $ opt_len]]
363: {
364: preferChaining(0) ,
365: chainingProhibited(1) ,
366: localScope(2) ,
367: dontUseCopy(3) ,
368: dontDereferenceAliases(4)
369: }
370: %{
371: %}
372: -- DEFAULT {} <<parm->svc_options != 0>> ,
373: OPTIONAL <<parm->svc_options != 0>> ,
374: priority
375: [1] INTEGER [[i parm->svc_prio]]
376: {
377: low(0) ,
378: medium(1) ,
379: high(2)
380: }
381: %{
382: %}
383: -- DEFAULT medium <<parm->svc_prio != SVC_PRIO_MED>> ,
384: OPTIONAL <<parm->svc_prio != SVC_PRIO_MED>> ,
385: timeLimit
386: [2] INTEGER [[i parm->svc_timelimit]]
387: %{
388: %}
389: OPTIONAL <<parm->svc_timelimit != SVC_NOTIMELIMIT>> ,
390: sizeLimit
391: [3] INTEGER [[i parm->svc_sizelimit]]
392: %{
393: %}
394: OPTIONAL <<parm->svc_sizelimit != SVC_NOSIZELIMIT>> ,
395: scopeOfReferral
396: [4] INTEGER [[i parm->svc_scopeofreferral]]
397: {
398: dmd(0) ,
399: country(1)
400: }
401: OPTIONAL <<parm->svc_scopeofreferral != SVC_REFSCOPE_NONE>>
402: }
403: %{
404: DLOG(log_dsap, LLOG_TRACE, ("Done encode ServiceControls (DAS)"));
405: %}
406:
407: ProtectionRequest [[P int]]
408: ::=
409: %{
410: DLOG(log_dsap, LLOG_TRACE, ("About to encode ProtectionRequest (DAS)"));
411: %}
412: INTEGER [[i parm]]
413: {
414: none (0) ,
415: signed (1)
416: }
417: %{
418: DLOG(log_dsap, LLOG_TRACE, ("Done encode ProtectionRequest (DAS)"));
419: %}
420:
421: SecurityParameters [[P struct security_parms *]]
422: ::=
423: %{
424: DLOG(log_dsap, LLOG_TRACE, ("About to encode SecurityParameters (DAS)"));
425: %}
426: SET
427: {
428: certificationPath
429: [0] CertificationPath [[p parm->sp_path]]
430: OPTIONAL <<parm->sp_path>> ,
431: name
432: [1] DistinguishedName [[p parm->sp_name]]
433: OPTIONAL <<parm->sp_name>> ,
434: time
435: [2] UTCTime [[s parm->sp_time]]
436: OPTIONAL <<parm->sp_time>> ,
437: random
438: [3] BIT STRING [[x parm->sp_random->value $ parm->sp_random->n_bits]]
439: OPTIONAL <<parm->sp_random>> ,
440: target
441: [4] ProtectionRequest [[p ((int) parm->sp_target)]]
442: OPTIONAL <<parm->sp_target != '\0'>>
443: }
444: %{
445: DLOG(log_dsap, LLOG_TRACE, ("Done encode SecurityParameters (DAS)"));
446: %}
447:
448: Extension [[P struct extension *]]
449: ::=
450: %{
451: DLOG(log_dsap, LLOG_TRACE, ("About to encode Extension (DAS)"));
452: %}
453: SET
454: {
455: identifier
456: [0] INTEGER [[i parm->ext_id]] ,
457: critical
458: [1] BOOLEAN [[b parm->ext_critical]]
459: -- DEFAULT FALSE ,
460: OPTIONAL <<parm->ext_critical != FALSE>> ,
461: item
462: [2] ANY DEFINED BY identifier [[a parm->ext_item]]
463: }
464: %{
465: DLOG(log_dsap, LLOG_TRACE, ("Done encode Extension (DAS)"));
466: %}
467:
468: EntryInformation [[P struct entrystruct *]]
469: %{
470: Attr_Sequence attr_temp;
471: %}
472: ::=
473: %{
474: DLOG(log_dsap, LLOG_TRACE, ("About to encode EntryInformation (DAS)"));
475: %}
476: SEQUENCE
477: {
478: DistinguishedName [[p parm->ent_dn]]
479: %{
480: %} ,
481: fromEntry
482: BOOLEAN [[b (parm->ent_iscopy == E_DATA_MASTER)]]
483: %{
484: %}
485: -- DEFAULT TRUE <<parm->ent_iscopy != E_DATA_MASTER>> ,
486: OPTIONAL <<parm->ent_iscopy != E_DATA_MASTER>> ,
487: SET OF
488: %{
489: %}
490: <<attr_temp=parm->ent_attr;attr_temp!=NULLATTR;attr_temp=attr_temp->attr_link>>
491: CHOICE
492: <<((attr_temp->attr_value == NULLAV) ? 1 : 2)>>
493: {
494: AttributeType [[p attr_temp->attr_type]]
495: %{
496: %} ,
497: Attribute [[p attr_temp]]
498: %{
499: %}
500: }
501: %{
502: %}
503: %{
504: %}
505: OPTIONAL <<parm->ent_attr != NULLATTR>>
506: }
507: %{
508: DLOG(log_dsap, LLOG_TRACE, ("Done encode EntryInformation (DAS)"));
509: %}
510:
511: LimitProblem [[P int]]
512: %{
513: %}
514: ::=
515: %{
516: DLOG(log_dsap, LLOG_TRACE, ("About to encode LimitProblem (DAS)"));
517: %}
518: INTEGER [[i parm]]
519: {
520: timeLimitExceeded(0) ,
521: sizeLimitExceeded(1) ,
522: administrativeLimitExceeded(2)
523: }
524: %{
525: DLOG(log_dsap, LLOG_TRACE, ("Done encode LimitProblem (DAS)"));
526: %}
527:
528: PartialOutcomeQualifier [[P struct part_outcome *]]
529: %{
530: ContinuationRef crefp;
531: %}
532: ::=
533: %{
534: DLOG(log_dsap, LLOG_TRACE, ("About to encode PartialOutcomeQualifier (DAS)"));
535: %}
536: SET
537: {
538: limitProblem
539: [0] LimitProblem [[p parm->poq_limitproblem]]
540: %{
541: %}
542: OPTIONAL <<parm->poq_limitproblem != LSR_NOLIMITPROBLEM>> ,
543: unexplored
544: [1] SET OF
545: %{
546: %}
547: <<crefp=parm->poq_cref;crefp!=NULLCONTINUATIONREF;crefp=crefp->cr_next>>
548: ContinuationReference [[p crefp]]
549: %{
550: %}
551: %{
552: %}
553: OPTIONAL <<parm->poq_cref != NULLCONTINUATIONREF>> ,
554: unavailableCriticalExtensions
555: [2] BOOLEAN
556: -- DEFAULT FALSE <<FALSE>>
557: -- OPTIONAL <<FALSE>>
558: OPTIONAL
559: }
560: %{
561: DLOG(log_dsap, LLOG_TRACE, ("Done encode PartialOutcomeQualifier (DAS)"));
562: %}
563:
564: FilterItem [[P struct filter_item *]]
565: %{
566: int subs_type;
567: AV_Sequence avs_temp;
568: Filter_Substrings *subs_temp;
569: %}
570: ::=
571: %{
572: DLOG(log_dsap, LLOG_TRACE, ("About to encode FilterItem (DAS)"));
573: %}
574: CHOICE
575: <<(parm->fi_type + 1)>>
576: {
577: equality
578: [0] AttributeValueAssertion [[p &(parm->fi_un.fi_un_ava)]]
579: %{
580: %} ,
581: substrings
582: %{
583: subs_temp = &(parm->UNSUB);
584: subs_type = 1;
585: if((avs_temp = subs_temp->fi_sub_initial) == NULLAV)
586: {
587: ++subs_type;
588: if((avs_temp = subs_temp->fi_sub_any) == NULLAV)
589: {
590: ++subs_type;
591: avs_temp = subs_temp->fi_sub_final;
592: }
593: }
594: %}
595: [1] SEQUENCE
596: {
597: type
598: AttributeType [[p subs_temp->fi_sub_type]]
599: %{
600: %} ,
601: strings
602: SEQUENCE OF
603: %{
604: %}
605: <<; avs_temp != NULLAV;>>
606: CHOICE
607: <<subs_type>>
608: {
609: initial
610: [0] AttributeValue [[p &avs_temp->avseq_av]]
611: %{
612: if((avs_temp = avs_temp->avseq_next) == NULLAV)
613: {
614: ++subs_type;
615: if((avs_temp = subs_temp->fi_sub_any) == NULLAV)
616: {
617: ++subs_type;
618: avs_temp = subs_temp->fi_sub_final;
619: }
620: }
621: %} ,
622: any
623: [1] AttributeValue [[p &avs_temp->avseq_av]]
624: %{
625: if((avs_temp = avs_temp->avseq_next) == NULLAV)
626: {
627: ++subs_type;
628: avs_temp = subs_temp->fi_sub_final;
629: }
630: %} ,
631: final
632: [2] AttributeValue [[p &avs_temp->avseq_av]]
633: %{
634: avs_temp = avs_temp->avseq_next;
635: %}
636: }
637: %{
638: %}
639: %{
640: %}
641: }
642: %{
643: %} ,
644: greaterOrEqual
645: [2] AttributeValueAssertion [[p &(parm->fi_un.fi_un_ava)]]
646: %{
647: %} ,
648: lessOrEqual
649: [3] AttributeValueAssertion [[p &(parm->fi_un.fi_un_ava)]]
650: %{
651: %} ,
652: present
653: [4] AttributeType [[p parm->fi_un.fi_un_type]]
654: %{
655: %} ,
656: approximateMatch
657: [5] AttributeValueAssertion [[p &(parm->fi_un.fi_un_ava)]]
658: %{
659: %}
660: }
661: %{
662: DLOG(log_dsap, LLOG_TRACE, ("Done encode FilterItem (DAS)"));
663: %}
664:
665: Filter [[P struct filter *]]
666: %{
667: Filter flt_temp;
668: %}
669: ::=
670: %{
671: DLOG(log_dsap, LLOG_TRACE, ("About to encode Filter PE"));
672: %}
673: CHOICE
674: <<(parm->flt_type + 1)>>
675: {
676: item
677: [0] FilterItem [[p &(parm->flt_un.flt_un_item)]]
678: %{
679: %} ,
680: and
681: [1] SET OF
682: %{
683: %}
684: <<flt_temp=parm->flt_un.flt_un_filter;flt_temp!=NULL;flt_temp=flt_temp->flt_next>>
685: Filter [[p flt_temp]]
686: %{
687: %}
688: %{
689: %} ,
690: or
691: [2] SET OF
692: %{
693: %}
694: <<flt_temp=parm->flt_un.flt_un_filter;flt_temp!=NULL;flt_temp=flt_temp->flt_next>>
695: Filter [[p flt_temp]]
696: %{
697: %}
698: %{
699: %} ,
700: not
701: [3] Filter [[p parm->flt_un.flt_un_filter]]
702: %{
703: %}
704: }
705: %{
706: DLOG(log_dsap, LLOG_TRACE, ("Done encode Filter PE"));
707: %}
708:
709: EntryModification [[P struct entrymod *]]
710: %{
711: %}
712: ::=
713: %{
714: DLOG(log_dsap, LLOG_TRACE, ("About to encode EntryModification PE"));
715: %}
716: CHOICE
717: <<(parm->em_type + 1)>>
718: {
719: addAttribute
720: [0] Attribute [[p parm->em_what]]
721: %{
722: %} ,
723: removeAttribute
724: [1] AttributeType [[p parm->em_what->attr_type]]
725: %{
726: %} ,
727: addValues
728: [2] Attribute [[p parm->em_what]]
729: %{
730: %} ,
731: removeValues
732: [3] Attribute [[p parm->em_what]]
733: %{
734: %}
735: }
736: %{
737: DLOG(log_dsap, LLOG_TRACE, ("Done encode EntryModification PE"));
738: %}
739:
740: AbandonProblem [[P int]]
741: %{
742: %}
743: ::=
744: %{
745: DLOG(log_dsap, LLOG_TRACE, ("About to encode AbandonProblem PE"));
746: %}
747: INTEGER [[i parm]]
748: {
749: noSuchOperation(1) ,
750: tooLate(2) ,
751: cannotAbandon(3)
752: }
753: %{
754: DLOG(log_dsap, LLOG_TRACE, ("Done encode AbandonProblem PE"));
755: %}
756:
757: AttributeProblem [[P int]]
758: %{
759: %}
760: ::=
761: %{
762: DLOG(log_dsap, LLOG_TRACE, ("About to encode AttributeProblem PE"));
763: %}
764: INTEGER [[i parm]]
765: {
766: noSuchAttributeOrValue(1) ,
767: invalidAttributeSyntax(2) ,
768: undefinedAttributeType(3) ,
769: inappropriateMatching(4) ,
770: constraintViolation(5) ,
771: attributeOrValueAlreadyExists(6)
772: }
773: %{
774: DLOG(log_dsap, LLOG_TRACE, ("Done encode AttributeProblem PE"));
775: %}
776:
777: NameProblem [[P int]]
778: %{
779: %}
780: ::=
781: %{
782: DLOG(log_dsap, LLOG_TRACE, ("About to encode NameProblem PE"));
783: %}
784: INTEGER [[i parm]]
785: {
786: noSuchObject(1) ,
787: aliasProblem(2) ,
788: invalidAttributeSyntax(3) ,
789: aliasDereferencingProblem(4)
790: }
791: %{
792: DLOG(log_dsap, LLOG_TRACE, ("Done encode NameProblem PE"));
793: %}
794:
795: UpdateProblem [[P int]]
796: %{
797: %}
798: ::=
799: %{
800: DLOG(log_dsap, LLOG_TRACE, ("About to encode UpdateProblem PE"));
801: %}
802: INTEGER [[i parm]]
803: {
804: namingViolation(1) ,
805: objectClassViolation(2) ,
806: notAllowedOnNonLeaf(3) ,
807: notAllowedOnRDN(4) ,
808: entryAlreadyExists(5) ,
809: affectsMultipleDSAs(6) ,
810: objectClassModificationProhibited(7)
811: }
812: %{
813: DLOG(log_dsap, LLOG_TRACE, ("Done encode UpdateProblem PE"));
814: %}
815:
816: DirectoryBindArgument [[P struct ds_bind_arg *]]
817: %{
818: /* Not used !!!
819: USC usc_s;
820: USC * usc = &(usc_s);
821: */
822: %}
823: ::=
824: %{
825: DLOG(log_dsap, LLOG_TRACE, ("About to encode DirectoryBindArgument"));
826: /* Not used !!!
827: * usc->usc_dn = parm->dba_dn;
828: * usc->usc_time1 = parm->dba_time1;
829: * usc->usc_time2 = parm->dba_time2;
830: * if((usc->usc_passwd_len = parm->dba_passwd_len) != 0)
831: * {
832: * usc->usc_passwd = strdup(parm->dba_passwd);
833: * }
834: * else
835: * {
836: * usc->usc_passwd = NULL;
837: * }
838: */
839: %}
840: SET
841: {
842: credentials
843: [0] Credentials [[p parm]]
844: %{
845: %}
846: OPTIONAL <<(parm->dba_auth_type != DBA_AUTH_NONE) || (parm->dba_dn != NULLDN)>> ,
847: versions
848: [1] Versions [[p parm->dba_version]]
849: %{
850: %}
851: -- DEFAULT v1988 <<parm->dba_version != DBA_VERSION_V1988>>
852: OPTIONAL <<parm->dba_version != DBA_VERSION_V1988>>
853: }
854: %{
855: DLOG(log_dsap, LLOG_TRACE, ("Done encode DirectoryBindArgument"));
856: %}
857:
858: DirectoryBindResult [[P struct ds_bind_arg *]]
859: %{
860: %}
861: ::=
862: %{
863: DLOG(log_dsap, LLOG_TRACE, ("About to encode DirectoryBindResult"));
864: %}
865: DirectoryBindArgument [[p parm]]
866: %{
867: DLOG(log_dsap, LLOG_TRACE, ("Done encode DirectoryBindResult"));
868: %}
869:
870: ReadArgumentData [[P struct ds_read_arg *]]
871: %{
872: struct common_args * ca;
873: struct extension * extp;
874: %}
875: ::=
876: %{
877: DLOG(log_dsap, LLOG_TRACE, ("About to encode ReadArgumentData PE"));
878: ca = &(parm->rda_common);
879: %}
880: SET
881: {
882: object
883: [0] Name [[p parm->rda_object]]
884: %{
885: %} ,
886: selection
887: [1] EntryInformationSelection [[p &(parm->rda_eis)]]
888: %{
889: %}
890: -- DEFAULT {} ,
891: OPTIONAL <<TRUE>> ,
892: [30] ServiceControls [[p &(ca->ca_servicecontrol)]]
893: %{
894: %}
895: -- DEFAULT {} ,
896: OPTIONAL <<TRUE>> ,
897: [29] SecurityParameters [[p ca->ca_security]]
898: -- DEFAULT {} ,
899: OPTIONAL <<ca->ca_security>> ,
900: requestor
901: [28] DistinguishedName [[p ca->ca_requestor]]
902: %{
903: %}
904: OPTIONAL <<ca->ca_requestor != NULLDN>> ,
905: [27] OperationProgress [[p &(ca->ca_progress)]]
906: %{
907: %}
908: OPTIONAL <<TRUE>> ,
909: aliasedRDNs
910: [26] INTEGER [[i ca->ca_aliased_rdns]]
911: OPTIONAL <<ca->ca_aliased_rdns != CA_NO_ALIASDEREFERENCED>> ,
912: extensions
913: [25] SET OF
914: <<extp=ca->ca_extensions; extp!=NULLEXT; extp=extp->ext_next>>
915: Extension [[p extp]]
916: OPTIONAL <<ca->ca_extensions != NULLEXT>>
917: }
918: %{
919: DLOG(log_dsap, LLOG_TRACE, ("Done encode ReadArgumentData PE"));
920: %}
921:
922: ReadArgument [[P struct ds_read_arg *]]
923: ::=
924: %{
925: DLOG(log_dsap, LLOG_TRACE, ("At encode ReadArgument"));
926: %}
927: CHOICE
928: <<(parm->rda_common.ca_sig == (struct signature *) 0)? 1:2>>
929: {
930: ReadArgumentData [[p parm]] ,
931: SEQUENCE
932: {
933: ReadArgumentData [[p parm]] ,
934: AlgorithmIdentifier
935: [[p &(parm->rda_common.ca_sig->alg)]],
936: BIT STRING
937: [[x (parm->rda_common.ca_sig->encrypted) $
938: (parm->rda_common.ca_sig->n_bits) ]]
939: }
940: }
941: %{
942: DLOG(log_dsap, LLOG_TRACE, ("Done encode ReadArgument"));
943: %}
944:
945: ReadResultData [[P struct ds_read_result *]]
946: %{
947: %}
948: ::=
949: %{
950: DLOG(log_dsap, LLOG_TRACE, ("About to encode ReadResultData PE"));
951: %}
952: SET
953: {
954: entry
955: [0] EntryInformation [[p &(parm->rdr_entry)]]
956: %{
957: %} ,
958: [30] SecurityParameters [[p (struct security_parms *)0 ]]
959: -- OPTIONAL <<FALSE>> ,
960: OPTIONAL ,
961: performer
962: [29] DistinguishedName [[p parm->rdr_common.cr_requestor]]
963: %{
964: %}
965: OPTIONAL <<parm->rdr_common.cr_requestor != NULLDN>> ,
966: aliasDereferenced
967: [28] BOOLEAN [[b parm->rdr_common.cr_aliasdereferenced]]
968: %{
969: %}
970: -- DEFAULT FALSE <<parm->rdr_common.cr_aliasdereferenced != FALSE>>
971: OPTIONAL <<parm->rdr_common.cr_aliasdereferenced != FALSE>>
972: }
973: %{
974: DLOG(log_dsap, LLOG_TRACE, ("Done encode ReadResultData PE"));
975: %}
976:
977: ReadResult [[P struct ds_read_result *]]
978: ::=
979: %{
980: DLOG(log_dsap, LLOG_TRACE, ("At encode ReadResult"));
981: %}
982: CHOICE
983: <<1>>
984: {
985: ReadResultData [[p parm]] ,
986: SEQUENCE
987: {
988: ReadResultData [[p parm]] ,
989: AlgorithmIdentifier [[p (struct alg_id *)0 ]],
990: BIT STRING
991: }
992: }
993: %{
994: DLOG(log_dsap, LLOG_TRACE, ("Done encode ReadResult"));
995: %}
996:
997: CompareArgumentData [[P struct ds_compare_arg *]]
998: %{
999: struct common_args * ca;
1000: struct extension * extp;
1001: %}
1002: ::=
1003: %{
1004: DLOG(log_dsap, LLOG_TRACE, ("About to encode CompareArgumentData PE"));
1005: ca = &(parm->cma_common);
1006: %}
1007: SET
1008: {
1009: object
1010: [0] Name [[p parm->cma_object]]
1011: %{
1012: %} ,
1013: purported
1014: [1] AttributeValueAssertion [[p &(parm->cma_purported)]]
1015: %{
1016: %} ,
1017: [30] ServiceControls [[p &(ca->ca_servicecontrol)]]
1018: %{
1019: %}
1020: -- DEFAULT {} ,
1021: OPTIONAL <<TRUE>> ,
1022: [29] SecurityParameters [[p ca->ca_security]]
1023: -- DEFAULT {} ,
1024: OPTIONAL <<ca->ca_security>> ,
1025: requestor
1026: [28] DistinguishedName [[p ca->ca_requestor]]
1027: %{
1028: %}
1029: OPTIONAL <<ca->ca_requestor != NULLDN>> ,
1030: [27] OperationProgress [[p &(ca->ca_progress)]]
1031: %{
1032: %}
1033: OPTIONAL <<TRUE>> ,
1034: aliasedRDNs
1035: [26] INTEGER [[i ca->ca_aliased_rdns]]
1036: OPTIONAL <<ca->ca_aliased_rdns != CA_NO_ALIASDEREFERENCED>> ,
1037: extensions
1038: [25] SET OF
1039: <<extp=ca->ca_extensions; extp!=NULLEXT; extp=extp->ext_next>>
1040: Extension [[p extp]]
1041: OPTIONAL <<ca->ca_extensions != NULLEXT>>
1042: }
1043: %{
1044: DLOG(log_dsap, LLOG_TRACE, ("Done encode CompareArgumentData PE"));
1045: %}
1046:
1047: CompareArgument [[P struct ds_compare_arg *]]
1048: ::=
1049: %{
1050: DLOG(log_dsap, LLOG_TRACE, ("At encode CompareArgument"));
1051: %}
1052: CHOICE
1053: <<(parm->cma_common.ca_sig == (struct signature *) 0)? 1:2>>
1054: {
1055: CompareArgumentData [[p parm]] ,
1056: SEQUENCE
1057: {
1058: CompareArgumentData [[p parm]] ,
1059: AlgorithmIdentifier
1060: [[p &(parm->cma_common.ca_sig->alg)]],
1061: BIT STRING
1062: [[x (parm->cma_common.ca_sig->encrypted) $
1063: (parm->cma_common.ca_sig->n_bits) ]]
1064: }
1065: }
1066: %{
1067: DLOG(log_dsap, LLOG_TRACE, ("Done encode CompareArgument"));
1068: %}
1069:
1070: CompareResultData [[P struct ds_compare_result *]]
1071: %{
1072: %}
1073: ::=
1074: %{
1075: DLOG(log_dsap, LLOG_TRACE, ("About to encode CompareResultData PE"));
1076: %}
1077: SET
1078: {
1079: DistinguishedName [[p parm->cmr_object]]
1080: %{
1081: %}
1082: OPTIONAL <<parm->cmr_object != NULLDN>> ,
1083: matched
1084: [0] BOOLEAN [[b parm->cmr_matched]]
1085: %{
1086: %} ,
1087: fromEntry
1088: [1] BOOLEAN [[b (parm->cmr_iscopy == E_DATA_MASTER)]]
1089: %{
1090: %}
1091: -- DEFAULT TRUE <<parm->cmr_iscopy != TRUE>> ,
1092: OPTIONAL <<parm->cmr_iscopy != E_DATA_MASTER>> ,
1093: [30] SecurityParameters [[p (struct security_parms *)0 ]]
1094: -- OPTIONAL <<FALSE>> ,
1095: OPTIONAL ,
1096: performer
1097: [29] DistinguishedName [[p parm->cmr_common.cr_requestor]]
1098: %{
1099: %}
1100: OPTIONAL <<parm->cmr_common.cr_requestor != NULLDN>> ,
1101: aliasDereferenced
1102: [28] BOOLEAN [[b parm->cmr_common.cr_aliasdereferenced]]
1103: %{
1104: %}
1105: -- DEFAULT FALSE <<parm->cmr_common.cr_aliasdereferenced != FALSE>>
1106: OPTIONAL <<parm->cmr_common.cr_aliasdereferenced != FALSE>>
1107: }
1108: %{
1109: DLOG(log_dsap, LLOG_TRACE, ("Done encode CompareResultData PE"));
1110: %}
1111:
1112: CompareResult [[P struct ds_compare_result *]]
1113: ::=
1114: %{
1115: DLOG(log_dsap, LLOG_TRACE, ("At encode CompareResult"));
1116: %}
1117: CHOICE
1118: <<1>>
1119: {
1120: CompareResultData [[p parm]] ,
1121: SEQUENCE
1122: {
1123: CompareResultData [[p parm]] ,
1124: AlgorithmIdentifier [[p (struct alg_id *)0 ]],
1125: BIT STRING
1126: }
1127: }
1128: %{
1129: DLOG(log_dsap, LLOG_TRACE, ("Done encode CompareResult"));
1130: %}
1131:
1132: AbandonArgument [[P struct ds_abandon_arg *]]
1133: %{
1134: %}
1135: ::=
1136: %{
1137: DLOG(log_dsap, LLOG_TRACE, ("About to encode AbandonArgument PE"));
1138: %}
1139: SEQUENCE
1140: {
1141: invokeID
1142: [0] InvokeID [[p parm->aba_invokeid]]
1143: %{
1144: %}
1145: }
1146: %{
1147: DLOG(log_dsap, LLOG_TRACE, ("Done encode AbandonArgument PE"));
1148: %}
1149:
1150: AbandonResult ::= NULL
1151:
1152: ListArgumentData [[P struct ds_list_arg *]]
1153: %{
1154: struct common_args * ca;
1155: struct extension * extp;
1156: %}
1157: ::=
1158: %{
1159: DLOG(log_dsap, LLOG_TRACE, ("About to encode ListArgumentData PE"));
1160: ca = &(parm->lsa_common);
1161: %}
1162: SET
1163: {
1164: object
1165: [0] Name [[p parm->lsa_object]]
1166: %{
1167: %} ,
1168: [30] ServiceControls [[p &(ca->ca_servicecontrol)]]
1169: %{
1170: %}
1171: -- DEFAULT {} ,
1172: OPTIONAL <<TRUE>> ,
1173: [29] SecurityParameters [[p ca->ca_security]]
1174: -- DEFAULT {} ,
1175: OPTIONAL <<ca->ca_security>> ,
1176: requestor
1177: [28] DistinguishedName [[p ca->ca_requestor]]
1178: %{
1179: %}
1180: OPTIONAL <<ca->ca_requestor != NULLDN>> ,
1181: [27] OperationProgress [[p &(ca->ca_progress)]]
1182: %{
1183: %}
1184: OPTIONAL <<TRUE>> ,
1185: aliasedRDNs
1186: [26] INTEGER [[i ca->ca_aliased_rdns]]
1187: OPTIONAL <<ca->ca_aliased_rdns != CA_NO_ALIASDEREFERENCED>> ,
1188: extensions
1189: [25] SET OF
1190: <<extp=ca->ca_extensions; extp!=NULLEXT; extp=extp->ext_next>>
1191: Extension [[p extp]]
1192: OPTIONAL <<ca->ca_extensions != NULLEXT>>
1193: }
1194: %{
1195: DLOG(log_dsap, LLOG_TRACE, ("Done encode ListArgumentData PE"));
1196: %}
1197:
1198: ListArgument [[P struct ds_list_arg *]]
1199: ::=
1200: %{
1201: DLOG(log_dsap, LLOG_TRACE, ("At encode ListArgument"));
1202: %}
1203: CHOICE
1204: <<(parm->lsa_common.ca_sig == (struct signature *) 0)? 1:2>>
1205: {
1206: ListArgumentData [[p parm]] ,
1207: SEQUENCE
1208: {
1209: ListArgumentData [[p parm]] ,
1210: AlgorithmIdentifier
1211: [[p &(parm->lsa_common.ca_sig->alg) ]],
1212: BIT STRING
1213: [[x (parm->lsa_common.ca_sig->encrypted) $
1214: (parm->lsa_common.ca_sig->n_bits) ]]
1215: }
1216: }
1217: %{
1218: DLOG(log_dsap, LLOG_TRACE, ("Done encode ListArgument"));
1219: %}
1220:
1221: ListResultData [[P struct ds_list_result *]]
1222: %{
1223: struct subordinate *sub_temp;
1224: POQ poq_s;
1225: POQ * poq = &(poq_s);
1226: %}
1227: ::=
1228: %{
1229: DLOG(log_dsap, LLOG_TRACE, ("About to encode ListResultData PE"));
1230: poq->poq_limitproblem = parm->lsr_limitproblem;
1231: poq->poq_cref = parm->lsr_cr;
1232: %}
1233: CHOICE
1234: <<1>>
1235: {
1236: listInfo
1237: SET
1238: {
1239: DistinguishedName [[p parm->lsr_object]]
1240: %{
1241: %}
1242: OPTIONAL <<parm->lsr_object != NULLDN>> ,
1243: subordinates
1244: [1] SET OF
1245: %{
1246: %}
1247: <<sub_temp=parm->lsr_subordinates;sub_temp!=NULL;sub_temp=sub_temp->sub_next>>
1248: SEQUENCE
1249: {
1250: RelativeDistinguishedName [[p sub_temp->sub_rdn]]
1251: %{
1252: %} ,
1253: aliasEntry
1254: [0] BOOLEAN [[b sub_temp->sub_aliasentry]]
1255: %{
1256: %}
1257: -- DEFAULT FALSE <<sub_temp->sub_aliasentry != FALSE>> ,
1258: OPTIONAL <<sub_temp->sub_aliasentry != FALSE>> ,
1259: fromEntry
1260: [1] BOOLEAN [[b (sub_temp->sub_copy == E_DATA_MASTER)]]
1261: %{
1262: %}
1263: -- DEFAULT TRUE <<sub_temp->sub_copy != E_DATA_MASTER>>
1264: OPTIONAL <<sub_temp->sub_copy != E_DATA_MASTER>>
1265: }
1266: %{
1267: %}
1268: %{
1269: %} ,
1270: partialOutcomeQualifier
1271: [2] PartialOutcomeQualifier [[p poq]]
1272: %{
1273: %}
1274: OPTIONAL <<((poq->poq_limitproblem != LSR_NOLIMITPROBLEM) || (poq->poq_cref != NULLCONTINUATIONREF))>> ,
1275: [30] SecurityParameters [[p (struct security_parms *)0 ]]
1276: -- OPTIONAL <<FALSE>> ,
1277: OPTIONAL ,
1278: performer
1279: [29] DistinguishedName [[p parm->lsr_common.cr_requestor]]
1280: %{
1281: %}
1282: OPTIONAL <<parm->lsr_common.cr_requestor != NULLDN>> ,
1283: aliasDereferenced
1284: [28] BOOLEAN [[b parm->lsr_common.cr_aliasdereferenced]]
1285: %{
1286: %}
1287: -- DEFAULT FALSE <<parm->lsr_common.cr_aliasdereferenced != FALSE>>
1288: OPTIONAL <<parm->lsr_common.cr_aliasdereferenced != FALSE>>
1289: }
1290: %{
1291: %} ,
1292: uncorrelatedListInfo
1293: [0] SET OF
1294: ListResult [[p ((struct ds_list_result *) 0)]]
1295: }
1296: %{
1297: DLOG(log_dsap, LLOG_TRACE, ("Done encode ListResultData PE"));
1298: %}
1299:
1300: ListResult [[P struct ds_list_result *]]
1301: ::=
1302: %{
1303: DLOG(log_dsap, LLOG_TRACE, ("At encode ListResult"));
1304: %}
1305: CHOICE
1306: <<1>>
1307: {
1308: ListResultData [[p parm]] ,
1309: SEQUENCE
1310: {
1311: ListResultData [[p parm]] ,
1312: AlgorithmIdentifier [[p (struct alg_id *)0 ]],
1313: BIT STRING
1314: }
1315: }
1316: %{
1317: DLOG(log_dsap, LLOG_TRACE, ("Done encode ListResult"));
1318: %}
1319:
1320: SearchArgumentData [[P struct ds_search_arg *]]
1321: %{
1322: struct common_args * ca;
1323: struct extension * extp;
1324: %}
1325: ::=
1326: %{
1327: DLOG(log_dsap, LLOG_TRACE, ("About to encode SearchArgumentData PE"));
1328: ca = &(parm->sra_common);
1329: %}
1330: SET
1331: {
1332: baseObject
1333: [0] Name [[p parm->sra_baseobject]]
1334: %{
1335: %} ,
1336: subset
1337: [1] INTEGER [[i parm->sra_subset]]
1338: {
1339: baseObject(0) ,
1340: oneLevel(1) ,
1341: wholeSubtree(2)
1342: }
1343: %{
1344: %}
1345: -- DEFAULT baseObject <<parm->sra_subset != SRA_BASEOBJECT>> ,
1346: OPTIONAL <<parm->sra_subset != SRA_BASEOBJECT>> ,
1347: filter
1348: [2] Filter [[p parm->sra_filter]]
1349: %{
1350: %}
1351: -- DEFAULT and {} ,
1352: OPTIONAL <<TRUE>> ,
1353: searchAliases
1354: [3] BOOLEAN [[b parm->sra_searchaliases]]
1355: -- DEFAULT TRUE ,
1356: OPTIONAL <<parm->sra_searchaliases != TRUE>> ,
1357: selection
1358: [4] EntryInformationSelection [[p &(parm->sra_eis)]]
1359: %{
1360: %}
1361: -- DEFAULT {} ,
1362: OPTIONAL <<TRUE>> ,
1363: [30] ServiceControls [[p &(ca->ca_servicecontrol)]]
1364: %{
1365: %}
1366: -- DEFAULT {} ,
1367: OPTIONAL <<TRUE>> ,
1368: [29] SecurityParameters [[p ca->ca_security]]
1369: -- DEFAULT {} ,
1370: OPTIONAL <<ca->ca_security>> ,
1371: requestor
1372: [28] DistinguishedName [[p ca->ca_requestor]]
1373: %{
1374: %}
1375: OPTIONAL <<ca->ca_requestor != NULLDN>> ,
1376: [27] OperationProgress [[p &(ca->ca_progress)]]
1377: %{
1378: %}
1379: OPTIONAL <<TRUE>> ,
1380: aliasedRDNs
1381: [26] INTEGER [[i ca->ca_aliased_rdns]]
1382: OPTIONAL <<ca->ca_aliased_rdns != CA_NO_ALIASDEREFERENCED>> ,
1383: extensions
1384: [25] SET OF
1385: <<extp=ca->ca_extensions; extp!=NULLEXT; extp=extp->ext_next>>
1386: Extension [[p extp]]
1387: OPTIONAL <<ca->ca_extensions != NULLEXT>>
1388: }
1389: %{
1390: DLOG(log_dsap, LLOG_TRACE, ("Done encode SearchArgumentData PE"));
1391: %}
1392:
1393: SearchArgument [[P struct ds_search_arg *]]
1394: ::=
1395: %{
1396: DLOG(log_dsap, LLOG_TRACE, ("About to encode SearchArgument (DAS)"));
1397: %}
1398: CHOICE
1399: <<(parm->sra_common.ca_sig == (struct signature *) 0)? 1:2>>
1400: {
1401: SearchArgumentData [[p parm]] ,
1402: SEQUENCE
1403: {
1404: SearchArgumentData [[p parm]] ,
1405: AlgorithmIdentifier
1406: [[p &(parm->sra_common.ca_sig->alg) ]],
1407: BIT STRING
1408: [[x (parm->sra_common.ca_sig->encrypted) $
1409: (parm->sra_common.ca_sig->n_bits) ]]
1410: }
1411: }
1412: %{
1413: DLOG(log_dsap, LLOG_TRACE, ("Done encode SearchArgument (DAS)"));
1414: %}
1415:
1416: SearchResultData [[P struct ds_search_result *]]
1417: %{
1418: struct ds_search_result *srr_temp;
1419: EntryInfo *ent_temp;
1420: POQ poq_s;
1421: POQ * poq = &(poq_s);
1422: %}
1423: ::=
1424: %{
1425: DLOG(log_dsap, LLOG_TRACE, ("About to encode SearchResultData PE"));
1426: %}
1427: CHOICE
1428: <<((parm->srr_correlated == FALSE) ? 2 : 1)>>
1429: {
1430: searchInfo
1431: %{
1432: poq->poq_limitproblem = parm->CSR_limitproblem;
1433: poq->poq_cref = parm->CSR_cr;
1434: %}
1435: SET
1436: {
1437: DistinguishedName [[p parm->CSR_object]]
1438: %{
1439: %}
1440: OPTIONAL <<parm->CSR_object != NULLDN>> ,
1441: entries
1442: [0] SET OF
1443: %{
1444: %}
1445: <<ent_temp=parm->CSR_entries;ent_temp!=NULLENTRYINFO;ent_temp=ent_temp->ent_next>>
1446: EntryInformation [[p ent_temp]]
1447: %{
1448: %}
1449: %{
1450: %} ,
1451: partialOutcomeQualifier
1452: [2] PartialOutcomeQualifier [[p poq]]
1453: %{
1454: %}
1455: OPTIONAL <<((poq->poq_limitproblem != LSR_NOLIMITPROBLEM) || (poq->poq_cref != NULLCONTINUATIONREF))>> ,
1456: [30] SecurityParameters [[p (struct security_parms *)0 ]]
1457: -- OPTIONAL <<FALSE>> ,
1458: OPTIONAL ,
1459: performer
1460: [29] DistinguishedName [[p parm->CSR_common.cr_requestor]]
1461: %{
1462: %}
1463: OPTIONAL <<parm->CSR_common.cr_requestor != NULLDN>> ,
1464: aliasDereferenced
1465: [28] BOOLEAN [[b parm->CSR_common.cr_aliasdereferenced]]
1466: %{
1467: %}
1468: -- DEFAULT FALSE <<parm->CSR_common.cr_aliasdereferenced != FALSE>>
1469: OPTIONAL <<parm->CSR_common.cr_aliasdereferenced != FALSE>>
1470: }
1471: %{
1472: %} ,
1473: uncorrelatedSearchInfo
1474: [0] SET OF
1475: %{
1476: %}
1477: <<srr_temp=parm->srr_un.srr_parts;srr_temp!=NULLSRR;srr_temp=srr_temp->srr_next>>
1478: SearchResult [[p srr_temp]]
1479: %{
1480: %}
1481: %{
1482: %}
1483: }
1484: %{
1485: DLOG(log_dsap, LLOG_TRACE, ("Done encode SearchResultData PE"));
1486: %}
1487:
1488: SearchResult [[P struct ds_search_result *]]
1489: ::=
1490: %{
1491: DLOG(log_dsap, LLOG_TRACE, ("At encode SearchResult"));
1492: %}
1493: CHOICE
1494: <<1>>
1495: {
1496: SearchResultData [[p parm]] ,
1497: SEQUENCE
1498: {
1499: SearchResultData [[p parm]] ,
1500: AlgorithmIdentifier [[p (struct alg_id *)0 ]],
1501: BIT STRING
1502: }
1503: }
1504: %{
1505: DLOG(log_dsap, LLOG_TRACE, ("Done encode SearchResult"));
1506: %}
1507:
1508: AddEntryArgumentData [[P struct ds_addentry_arg *]]
1509: %{
1510: struct common_args * ca;
1511: struct extension * extp;
1512: Attr_Sequence attr_temp;
1513: %}
1514: ::=
1515: %{
1516: DLOG(log_dsap, LLOG_TRACE, ("About to encode AddEntryArgumentData PE"));
1517: ca = &(parm->ada_common);
1518: %}
1519: SET
1520: {
1521: object
1522: [0] DistinguishedName [[p parm->ada_object]]
1523: %{
1524: %} ,
1525: entry
1526: [1] SET OF
1527: %{
1528: %}
1529: <<attr_temp=parm->ada_entry;attr_temp!=NULLATTR;attr_temp=attr_temp->attr_link>>
1530: Attribute [[p attr_temp]]
1531: %{
1532: %}
1533: %{
1534: %} ,
1535: [30] ServiceControls [[p &(ca->ca_servicecontrol)]]
1536: %{
1537: %}
1538: -- DEFAULT {} ,
1539: OPTIONAL <<TRUE>> ,
1540: [29] SecurityParameters [[p ca->ca_security]]
1541: -- DEFAULT {} ,
1542: OPTIONAL <<ca->ca_security>> ,
1543: requestor
1544: [28] DistinguishedName [[p ca->ca_requestor]]
1545: %{
1546: %}
1547: OPTIONAL <<ca->ca_requestor != NULLDN>> ,
1548: [27] OperationProgress [[p &(ca->ca_progress)]]
1549: %{
1550: %}
1551: OPTIONAL <<TRUE>> ,
1552: aliasedRDNs
1553: [26] INTEGER [[i ca->ca_aliased_rdns]]
1554: OPTIONAL <<ca->ca_aliased_rdns != CA_NO_ALIASDEREFERENCED>> ,
1555: extensions
1556: [25] SET OF
1557: <<extp=ca->ca_extensions; extp!=NULLEXT; extp=extp->ext_next>>
1558: Extension [[p extp]]
1559: OPTIONAL <<ca->ca_extensions != NULLEXT>>
1560: }
1561: %{
1562: DLOG(log_dsap, LLOG_TRACE, ("Done encode AddEntryArgumentData PE"));
1563: %}
1564:
1565: AddEntryArgument [[P struct ds_addentry_arg *]]
1566: ::=
1567: %{
1568: DLOG(log_dsap, LLOG_TRACE, ("At encode AddEntryArgument"));
1569: %}
1570: CHOICE
1571: <<(parm->ada_common.ca_sig == (struct signature *) 0)? 1:2>>
1572: {
1573: AddEntryArgumentData [[p parm]] ,
1574: SEQUENCE
1575: {
1576: AddEntryArgumentData [[p parm]] ,
1577: AlgorithmIdentifier
1578: [[p &(parm->ada_common.ca_sig->alg) ]],
1579: BIT STRING
1580: [[x (parm->ada_common.ca_sig->encrypted) $
1581: (parm->ada_common.ca_sig->n_bits) ]]
1582: }
1583: }
1584: %{
1585: DLOG(log_dsap, LLOG_TRACE, ("Done encode AddEntryArgument"));
1586: %}
1587:
1588: AddEntryResult ::= NULL
1589:
1590: RemoveEntryArgumentData [[P struct ds_removeentry_arg *]]
1591: %{
1592: struct common_args * ca;
1593: struct extension * extp;
1594: %}
1595: ::=
1596: %{
1597: DLOG(log_dsap, LLOG_TRACE, ("About to encode RemoveEntryArgumentData PE"));
1598: ca = &(parm->rma_common);
1599: %}
1600: SET
1601: {
1602: object
1603: [0] DistinguishedName [[p parm->rma_object]]
1604: %{
1605: %} ,
1606: [30] ServiceControls [[p &(ca->ca_servicecontrol)]]
1607: %{
1608: %}
1609: -- DEFAULT {} ,
1610: OPTIONAL <<TRUE>> ,
1611: [29] SecurityParameters [[p ca->ca_security]]
1612: -- DEFAULT {} ,
1613: OPTIONAL <<ca->ca_security>> ,
1614: requestor
1615: [28] DistinguishedName [[p ca->ca_requestor]]
1616: %{
1617: %}
1618: OPTIONAL <<ca->ca_requestor != NULLDN>> ,
1619: [27] OperationProgress [[p &(ca->ca_progress)]]
1620: %{
1621: %}
1622: OPTIONAL <<TRUE>> ,
1623: aliasedRDNs
1624: [26] INTEGER [[i ca->ca_aliased_rdns]]
1625: OPTIONAL <<ca->ca_aliased_rdns != CA_NO_ALIASDEREFERENCED>> ,
1626: extensions
1627: [25] SET OF
1628: <<extp=ca->ca_extensions; extp!=NULLEXT; extp=extp->ext_next>>
1629: Extension [[p extp]]
1630: OPTIONAL <<ca->ca_extensions != NULLEXT>>
1631: }
1632: %{
1633: DLOG(log_dsap, LLOG_TRACE, ("Done encode RemoveEntryArgumentData PE"));
1634: %}
1635:
1636: RemoveEntryArgument [[P struct ds_removeentry_arg *]]
1637: ::=
1638: %{
1639: DLOG(log_dsap, LLOG_TRACE, ("At encode RemoveEntryArgument"));
1640: %}
1641: CHOICE
1642: <<(parm->rma_common.ca_sig == (struct signature *) 0)? 1:2>>
1643: {
1644: RemoveEntryArgumentData [[p parm]] ,
1645: SEQUENCE
1646: {
1647: RemoveEntryArgumentData [[p parm]] ,
1648: AlgorithmIdentifier
1649: [[p &(parm->rma_common.ca_sig->alg) ]],
1650: BIT STRING
1651: [[x (parm->rma_common.ca_sig->encrypted) $
1652: (parm->rma_common.ca_sig->n_bits) ]]
1653: }
1654: }
1655: %{
1656: DLOG(log_dsap, LLOG_TRACE, ("Done encode RemoveEntryArgument"));
1657: %}
1658:
1659: RemoveEntryResult ::= NULL
1660:
1661: ModifyEntryArgumentData [[P struct ds_modifyentry_arg *]]
1662: %{
1663: struct common_args * ca;
1664: struct extension * extp;
1665: struct entrymod *em_temp;
1666: %}
1667: ::=
1668: %{
1669: DLOG(log_dsap, LLOG_TRACE, ("About to encode ModifyEntryArgumentData PE"));
1670: ca = &(parm->mea_common);
1671: %}
1672: SET
1673: {
1674: object
1675: [0] DistinguishedName [[p parm->mea_object]]
1676: %{
1677: %} ,
1678: changes
1679: [1] SEQUENCE OF
1680: %{
1681: %}
1682: <<em_temp=parm->mea_changes;em_temp!=NULL;em_temp=em_temp->em_next>>
1683: EntryModification [[p em_temp]]
1684: %{
1685: %}
1686: %{
1687: %} ,
1688: [30] ServiceControls [[p &(ca->ca_servicecontrol)]]
1689: %{
1690: %}
1691: -- DEFAULT {} ,
1692: OPTIONAL <<TRUE>> ,
1693: [29] SecurityParameters [[p ca->ca_security]]
1694: -- DEFAULT {} ,
1695: OPTIONAL <<ca->ca_security>> ,
1696: requestor
1697: [28] DistinguishedName [[p ca->ca_requestor]]
1698: %{
1699: %}
1700: OPTIONAL <<ca->ca_requestor != NULLDN>> ,
1701: [27] OperationProgress [[p &(ca->ca_progress)]]
1702: %{
1703: %}
1704: OPTIONAL <<TRUE>> ,
1705: aliasedRDNs
1706: [26] INTEGER [[i ca->ca_aliased_rdns]]
1707: OPTIONAL <<ca->ca_aliased_rdns != CA_NO_ALIASDEREFERENCED>> ,
1708: extensions
1709: [25] SET OF
1710: <<extp=ca->ca_extensions; extp!=NULLEXT; extp=extp->ext_next>>
1711: Extension [[p extp]]
1712: OPTIONAL <<ca->ca_extensions != NULLEXT>>
1713: }
1714: %{
1715: DLOG(log_dsap, LLOG_TRACE, ("Done encode ModifyEntryArgumentData PE"));
1716: %}
1717:
1718: ModifyEntryArgument [[P struct ds_modifyentry_arg *]]
1719: ::=
1720: %{
1721: DLOG(log_dsap, LLOG_TRACE, ("At encode ModifyEntryArgument"));
1722: %}
1723: CHOICE
1724: <<(parm->mea_common.ca_sig == (struct signature *) 0) ? 1 : 2>>
1725: {
1726: ModifyEntryArgumentData [[p parm]] ,
1727: SEQUENCE
1728: {
1729: ModifyEntryArgumentData [[p parm]] ,
1730: AlgorithmIdentifier [[p &(parm->mea_common.ca_sig->alg)]],
1731: BIT STRING [[x (parm->mea_common.ca_sig->encrypted) $ (parm->mea_common.ca_sig->n_bits) ]]
1732: }
1733: }
1734: %{
1735: DLOG(log_dsap, LLOG_TRACE, ("Done encode ModifyEntryArgument"));
1736: %}
1737:
1738: ModifyEntryResult ::= NULL
1739:
1740: ModifyRDNArgumentData [[P struct ds_modifyrdn_arg *]]
1741: %{
1742: struct common_args * ca;
1743: struct extension * extp;
1744: %}
1745: ::=
1746: %{
1747: DLOG(log_dsap, LLOG_TRACE, ("About to encode ModifyRDNArgumentData PE"));
1748: ca = &(parm->mra_common);
1749: %}
1750: SET
1751: {
1752: object
1753: [0] DistinguishedName [[p parm->mra_object]]
1754: %{
1755: %} ,
1756: newRDN
1757: [1] RelativeDistinguishedName [[p parm->mra_newrdn]]
1758: %{
1759: %} ,
1760: deleteRDN
1761: [2] BOOLEAN [[b parm->deleterdn]]
1762: %{
1763: %}
1764: -- DEFAULT FALSE <<parm->deleterdn != FALSE>> ,
1765: OPTIONAL <<parm->deleterdn != FALSE>> ,
1766: [30] ServiceControls [[p &(ca->ca_servicecontrol)]]
1767: %{
1768: %}
1769: -- DEFAULT {} ,
1770: OPTIONAL <<TRUE>> ,
1771: [29] SecurityParameters [[p ca->ca_security]]
1772: -- DEFAULT {} ,
1773: OPTIONAL <<ca->ca_security>> ,
1774: requestor
1775: [28] DistinguishedName [[p ca->ca_requestor]]
1776: %{
1777: %}
1778: OPTIONAL <<ca->ca_requestor != NULLDN>> ,
1779: [27] OperationProgress [[p &(ca->ca_progress)]]
1780: %{
1781: %}
1782: OPTIONAL <<TRUE>> ,
1783: aliasedRDNs
1784: [26] INTEGER [[i ca->ca_aliased_rdns]]
1785: OPTIONAL <<ca->ca_aliased_rdns != CA_NO_ALIASDEREFERENCED>> ,
1786: extensions
1787: [25] SET OF
1788: <<extp=ca->ca_extensions; extp!=NULLEXT; extp=extp->ext_next>>
1789: Extension [[p extp]]
1790: OPTIONAL <<ca->ca_extensions != NULLEXT>>
1791: }
1792: %{
1793: DLOG(log_dsap, LLOG_TRACE, ("Done encode ModifyRDNArgumentData PE"));
1794: %}
1795:
1796: ModifyRDNArgument [[P struct ds_modifyrdn_arg *]]
1797: ::=
1798: %{
1799: DLOG(log_dsap, LLOG_TRACE, ("At encode ModifyRDNArgument"));
1800: %}
1801: CHOICE
1802: <<(parm->mra_common.ca_sig == (struct signature *) 0)? 1:2>>
1803: {
1804: ModifyRDNArgumentData [[p parm]] ,
1805: SEQUENCE
1806: {
1807: ModifyRDNArgumentData [[p parm]] ,
1808: AlgorithmIdentifier
1809: [[p &(parm->mra_common.ca_sig->alg)]],
1810: BIT STRING [[x (parm->mra_common.ca_sig->encrypted) $
1811: (parm->mra_common.ca_sig->n_bits) ]]
1812: }
1813: }
1814: %{
1815: DLOG(log_dsap, LLOG_TRACE, ("Done encode ModifyRDNArgument"));
1816: %}
1817:
1818: ModifyRDNResult ::= NULL
1819:
1820: DirectoryBindError [[P struct ds_bind_error *]]
1821: %{
1822: %}
1823: ::=
1824: %{
1825: DLOG(log_dsap, LLOG_TRACE, ("About to encode DirectoryBindError"));
1826: %}
1827: SET
1828: {
1829: versions
1830: [0] Versions [[p parm->dbe_version]]
1831: %{
1832: %}
1833: -- DEFAULT v1988 <<parm->dbe_version != DBA_VERSION_V1988>> ,
1834: OPTIONAL <<parm->dbe_version != DBA_VERSION_V1988>> ,
1835: CHOICE
1836: <<(parm->dbe_type + 1)>>
1837: {
1838: serviceError
1839: [1] ServiceProblem [[p parm->dbe_value]]
1840: %{
1841: %} ,
1842: securityError
1843: [2] SecurityProblem [[p parm->dbe_value]]
1844: %{
1845: %}
1846: }
1847: %{
1848: %}
1849: }
1850: %{
1851: DLOG(log_dsap, LLOG_TRACE, ("Done encode DirectoryBindError"));
1852: %}
1853:
1854: AbandonFailedParm [[P struct DSE_abandon_fail *]]
1855: %{
1856: %}
1857: ::=
1858: %{
1859: DLOG(log_dsap, LLOG_TRACE, ("About to encode AbandonFailedParm PE"));
1860: %}
1861: SET
1862: %{
1863: %}
1864: {
1865: problem
1866: [0] AbandonProblem [[p parm->DSE_ab_problem]]
1867: %{
1868: %} ,
1869: operation
1870: [1] InvokeID [[p parm->DSE_ab_invokeid]]
1871: %{
1872: %}
1873: }
1874: %{
1875: DLOG(log_dsap, LLOG_TRACE, ("Done encode AbandonFailedParm PE"));
1876: %}
1877:
1878: AttributeErrorParm [[P struct DSE_attribute *]]
1879: %{
1880: struct DSE_at_problem *atp;
1881: %}
1882: ::=
1883: %{
1884: DLOG(log_dsap, LLOG_TRACE, ("About to encode AttributeErrorParm PE"));
1885: %}
1886: SET
1887: %{
1888: %}
1889: {
1890: object
1891: [0] Name [[p parm->DSE_at_name]]
1892: %{
1893: %} ,
1894: problems
1895: [1] SET OF
1896: %{
1897: %}
1898: <<atp = &(parm->DSE_at_plist);(atp!=DSE_AT_NOPROBLEM) && atp->DSE_at_what;atp=atp->dse_at_next>>
1899: SEQUENCE
1900: %{
1901: %}
1902: {
1903: problem
1904: [0] AttributeProblem [[p atp->DSE_at_what]]
1905: %{
1906: %} ,
1907: type
1908: [1] AttributeType [[p atp->DSE_at_type]]
1909: %{
1910: %} ,
1911: value
1912: [2] AttributeValue [[p atp->DSE_at_value]]
1913: %{
1914: %}
1915: OPTIONAL <<atp->DSE_at_value != NULLAttrV>>
1916: }
1917: %{
1918: %}
1919: %{
1920: %}
1921: }
1922: %{
1923: DLOG(log_dsap, LLOG_TRACE, ("Done encode AttributeErrorParm PE"));
1924: %}
1925:
1926: NameErrorParm [[P struct DSE_name *]]
1927: %{
1928: %}
1929: ::=
1930: %{
1931: DLOG(log_dsap, LLOG_TRACE, ("About to encode NameErrorParm PE"));
1932: %}
1933: SET
1934: %{
1935: %}
1936: {
1937: problem
1938: [0] NameProblem [[p parm->DSE_na_problem]]
1939: %{
1940: %} ,
1941: matched
1942: [1] Name [[p parm->DSE_na_matched]]
1943: %{
1944: %}
1945: }
1946: %{
1947: DLOG(log_dsap, LLOG_TRACE, ("Done encode NameErrorParm PE"));
1948: %}
1949:
1950: ReferralParm [[P struct DSE_referral *]]
1951: %{
1952: %}
1953: ::=
1954: %{
1955: DLOG(log_dsap, LLOG_TRACE, ("About to encode ReferralParm PE"));
1956: %}
1957: SET
1958: %{
1959: %}
1960: {
1961: candidate
1962: [0] ContinuationReference [[p parm->DSE_ref_candidates]]
1963: %{
1964: %}
1965: }
1966: %{
1967: DLOG(log_dsap, LLOG_TRACE, ("Done encode ReferralParm PE"));
1968: %}
1969:
1970: SecurityErrorParm [[P struct DSE_security *]]
1971: %{
1972: %}
1973: ::=
1974: %{
1975: DLOG(log_dsap, LLOG_TRACE, ("About to encode SecurityErrorParm PE"));
1976: %}
1977: SET
1978: %{
1979: %}
1980: {
1981: problem
1982: [0] SecurityProblem [[p parm->DSE_sc_problem]]
1983: %{
1984: %}
1985: }
1986: %{
1987: DLOG(log_dsap, LLOG_TRACE, ("Done encode SecurityErrorParm PE"));
1988: %}
1989:
1990: ServiceErrorParm [[P struct DSE_service *]]
1991: %{
1992: %}
1993: ::=
1994: %{
1995: DLOG(log_dsap, LLOG_TRACE, ("About to encode ServiceErrorParm PE"));
1996: %}
1997: SET
1998: %{
1999: %}
2000: {
2001: problem
2002: [0] ServiceProblem [[p parm->DSE_sv_problem]]
2003: %{
2004: %}
2005: }
2006: %{
2007: DLOG(log_dsap, LLOG_TRACE, ("Done encode ServiceErrorParm PE"));
2008: %}
2009:
2010: UpdateErrorParm [[P struct DSE_update *]]
2011: %{
2012: %}
2013: ::=
2014: %{
2015: DLOG(log_dsap, LLOG_TRACE, ("About to encode UpdateErrorParm PE"));
2016: %}
2017: SET
2018: %{
2019: %}
2020: {
2021: problem
2022: [0] UpdateProblem [[p parm->DSE_up_problem]]
2023: %{
2024: %}
2025: }
2026: %{
2027: DLOG(log_dsap, LLOG_TRACE, ("Done encode UpdateErrorParm PE"));
2028: %}
2029:
2030: END
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.