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