![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to do-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 do-dec.py CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / dsap / x500as |
1.1 root 1: -- do-dec.py - manually augmented DistributedOperations module
2:
3: -- $Header: /f/osi/dsap/x500as/RCS/do-dec.py,v 7.1 90/07/09 14:35:56 mrose Exp $
4: --
5: --
6: -- $Log: do-dec.py,v $
7: -- Revision 7.1 90/07/09 14:35:56 mrose
8: -- sync
9: --
10: -- Revision 7.0 89/11/23 21:50:23 mrose
11: -- Release 6.0
12: --
13:
14: --
15: -- NOTICE
16: --
17: -- Acquisition, use, and distribution of this module and related
18: -- materials are subject to the restrictions of a license agreement.
19: -- Consult the Preface in the User's Manual for the full terms of
20: -- this agreement.
21: --
22: --
23:
24:
25: DO
26: {
27: joint-iso-ccitt
28: ds(5)
29: modules(1)
30: distributedOperations(3)
31: }
32:
33: DEFINITIONS ::=
34:
35: %{
36: #include "quipu/util.h"
37: #include "quipu/entry.h"
38: #include "quipu/common.h"
39: #include "quipu/dsargument.h"
40:
41: extern LLog * log_dsap;
42:
43: #define decode_DSE_PSAPaddr parse_DSE_PSAPaddr
44: #define decode_UNIV_UTCTime parse_UNIV_UTCTime
45:
46: %}
47:
48: PREFIXES encode decode print
49: BEGIN
50:
51: -- EXPORTS
52: -- ContinuationReference ,
53: -- OperationProgress ,
54: -- DSAReferralParm;
55:
56: IMPORTS
57: DistinguishedName ,
58: Name ,
59: RelativeDistinguishedName
60: FROM IF
61: {
62: joint-iso-ccitt
63: ds(5)
64: modules(1)
65: informationFramework(1)
66: }
67:
68: AlgorithmIdentifier
69: FROM AF
70: {
71: joint-iso-ccitt
72: ds(5)
73: modules(1)
74: authenticationFramework(7)
75: }
76:
77: ReadArgument ,
78: ReadResult ,
79: CompareArgument ,
80: CompareResult ,
81: AbandonArgument ,
82: AbandonResult ,
83: ListArgument ,
84: ListResult ,
85: SearchArgument ,
86: SearchResult ,
87: AddEntryArgument ,
88: AddEntryResult ,
89: RemoveEntryArgument ,
90: RemoveEntryResult ,
91: ModifyEntryArgument ,
92: ModifyEntryResult ,
93: ModifyRDNArgument ,
94: ModifyRDNResult ,
95: SecurityParameters
96: FROM DAS
97: {
98: joint-iso-ccitt
99: ds(5)
100: modules(1)
101: directoryAbstractService(2)
102: };
103:
104: DECODER decode
105:
106: ChainedReadArgument [[P struct ds_op_arg *]]
107: ::=
108: %{
109: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedReadArgument"));
110: %}
111: CHOICE
112: {
113: ChainedReadArgumentData [[p parm]] ,
114: SEQUENCE
115: {
116: ChainedReadArgumentData [[p parm]] ,
117: AlgorithmIdentifier [[p (struct alg_id *)0 ]] ,
118: BIT STRING
119: }
120: }
121: %{
122: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedReadArgument"));
123: %}
124:
125: ChainedReadArgumentData [[P struct ds_op_arg *]]
126: ::=
127: %{
128: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedReadArgumentData"));
129: parm->dca_dsarg.arg_type = OP_READ;
130: %}
131: SET
132: {
133: ChainingArgument [[p &(parm->dca_charg)]] ,
134: [0] ReadArgument [[p &(parm->dca_dsarg.arg_rd)]]
135: }
136: %{
137: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedReadArgumentData"));
138: %}
139:
140: ChainedReadResult [[P struct ds_op_res *]]
141: ::=
142: %{
143: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedReadResult"));
144: %}
145: CHOICE
146: {
147: ChainedReadResultData [[p parm]] ,
148: SEQUENCE
149: {
150: ChainedReadResultData [[p parm]] ,
151: AlgorithmIdentifier [[p (struct alg_id *)0 ]] ,
152: BIT STRING
153: }
154: }
155: %{
156: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedReadResult"));
157: %}
158:
159: ChainedReadResultData [[P struct ds_op_res *]]
160: ::=
161: %{
162: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedReadResultData"));
163: parm->dcr_dsres.result_type = OP_READ;
164: %}
165: SET
166: {
167: ChainingResult [[p &(parm->dcr_chres)]] ,
168: [0] ReadResult [[p &(parm->dcr_dsres.res_rd)]]
169: }
170: %{
171: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedReadResultData"));
172: %}
173:
174: ChainedCompareArgument [[P struct ds_op_arg *]]
175: ::=
176: %{
177: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedCompareArgument"));
178: %}
179: CHOICE
180: {
181: ChainedCompareArgumentData [[p parm]] ,
182: SEQUENCE
183: {
184: ChainedCompareArgumentData [[p parm]] ,
185: AlgorithmIdentifier [[p (struct alg_id *)0 ]] ,
186: BIT STRING
187: }
188: }
189: %{
190: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedCompareArgument"));
191: %}
192:
193: ChainedCompareArgumentData [[P struct ds_op_arg *]]
194: ::=
195: %{
196: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedCompareArgumentData"));
197: parm->dca_dsarg.arg_type = OP_COMPARE;
198: %}
199: SET
200: {
201: ChainingArgument [[p &(parm->dca_charg)]] ,
202: [0] CompareArgument [[p &(parm->dca_dsarg.arg_cm)]]
203: }
204: %{
205: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedCompareArgumentData"));
206: %}
207:
208: ChainedCompareResult [[P struct ds_op_res *]]
209: ::=
210: %{
211: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedCompareResult"));
212: %}
213: CHOICE
214: {
215: ChainedCompareResultData [[p parm]] ,
216: SEQUENCE
217: {
218: ChainedCompareResultData [[p parm]] ,
219: AlgorithmIdentifier [[p (struct alg_id *)0 ]] ,
220: BIT STRING
221: }
222: }
223: %{
224: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedCompareResult"));
225: %}
226:
227: ChainedCompareResultData [[P struct ds_op_res *]]
228: ::=
229: %{
230: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedCompareResultData"));
231: parm->dcr_dsres.result_type = OP_COMPARE;
232: %}
233: SET
234: {
235: ChainingResult [[p &(parm->dcr_chres)]] ,
236: [0] CompareResult [[p &(parm->dcr_dsres.res_cm)]]
237: }
238: %{
239: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedCompareResultData"));
240: %}
241:
242: ChainedAbandonArgument [[P struct ds_op_arg *]]
243: ::=
244: %{
245: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedAbandonArgument"));
246: parm->dca_dsarg.arg_type = OP_ABANDON;
247: %}
248: AbandonArgument [[p &(parm->dca_dsarg.arg_ab)]]
249: %{
250: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedAbandonArgument"));
251: %}
252:
253: ChainedAbandonResult [[P struct ds_op_res *]]
254: ::=
255: %{
256: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedAbandonResult"));
257: parm->dcr_dsres.result_type = OP_ABANDON;
258: %}
259: AbandonResult
260: %{
261: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedAbandonResult"));
262: %}
263:
264: ChainedListArgument [[P struct ds_op_arg *]]
265: ::=
266: %{
267: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedListArgument"));
268: %}
269: CHOICE
270: {
271: ChainedListArgumentData [[p parm]] ,
272: SEQUENCE
273: {
274: ChainedListArgumentData [[p parm]] ,
275: AlgorithmIdentifier [[p (struct alg_id *)0 ]] ,
276: BIT STRING
277: }
278: }
279: %{
280: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedListArgument"));
281: %}
282:
283: ChainedListArgumentData [[P struct ds_op_arg *]]
284: ::=
285: %{
286: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedListArgumentData"));
287: parm->dca_dsarg.arg_type = OP_LIST;
288: %}
289: SET
290: {
291: ChainingArgument [[p &(parm->dca_charg)]] ,
292: [0] ListArgument [[p &(parm->dca_dsarg.arg_ls)]]
293: }
294: %{
295: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedListArgumentData"));
296: %}
297:
298: ChainedListResult [[P struct ds_op_res *]]
299: ::=
300: %{
301: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedListResult"));
302: %}
303: CHOICE
304: {
305: ChainedListResultData [[p parm]] ,
306: SEQUENCE
307: {
308: ChainedListResultData [[p parm]] ,
309: AlgorithmIdentifier [[p (struct alg_id *)0 ]] ,
310: BIT STRING
311: }
312: }
313: %{
314: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedListResult"));
315: %}
316:
317: ChainedListResultData [[P struct ds_op_res *]]
318: ::=
319: %{
320: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedListResultData"));
321: parm->dcr_dsres.result_type = OP_LIST;
322: %}
323: SET
324: {
325: ChainingResult [[p &(parm->dcr_chres)]] ,
326: [0] ListResult [[p &(parm->dcr_dsres.res_ls)]]
327: }
328: %{
329: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedListResultData"));
330: %}
331:
332: ChainedSearchArgument [[P struct ds_op_arg *]]
333: ::=
334: %{
335: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedSearchArgument"));
336: %}
337: CHOICE
338: {
339: ChainedSearchArgumentData [[p parm]] ,
340: SEQUENCE
341: {
342: ChainedSearchArgumentData [[p parm]] ,
343: AlgorithmIdentifier [[p (struct alg_id *)0 ]] ,
344: BIT STRING
345: }
346: }
347: %{
348: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedSearchArgument"));
349: %}
350:
351: ChainedSearchArgumentData [[P struct ds_op_arg *]]
352: ::=
353: %{
354: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedSearchArgumentData"));
355: parm->dca_dsarg.arg_type = OP_SEARCH;
356: %}
357: SET
358: {
359: ChainingArgument [[p &(parm->dca_charg)]] ,
360: [0] SearchArgument [[p &(parm->dca_dsarg.arg_sr)]]
361: }
362: %{
363: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedSearchArgumentData"));
364: %}
365:
366: ChainedSearchResult [[P struct ds_op_res *]]
367: ::=
368: %{
369: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedSearchResult"));
370: %}
371: CHOICE
372: {
373: ChainedSearchResultData [[p parm]] ,
374: SEQUENCE
375: {
376: ChainedSearchResultData [[p parm]] ,
377: AlgorithmIdentifier [[p (struct alg_id *)0 ]] ,
378: BIT STRING
379: }
380: }
381: %{
382: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedSearchResult"));
383: %}
384:
385: ChainedSearchResultData [[P struct ds_op_res *]]
386: ::=
387: %{
388: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedSearchResultData"));
389: parm->dcr_dsres.result_type = OP_SEARCH;
390: %}
391: SET
392: {
393: ChainingResult [[p &(parm->dcr_chres)]] ,
394: [0] SearchResult [[p &(parm->dcr_dsres.res_sr)]]
395: }
396: %{
397: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedSearchResultData"));
398: %}
399:
400: ChainedAddEntryArgument [[P struct ds_op_arg *]]
401: ::=
402: %{
403: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedAddEntryArgument"));
404: %}
405: CHOICE
406: {
407: ChainedAddEntryArgumentData [[p parm]] ,
408: SEQUENCE
409: {
410: ChainedAddEntryArgumentData [[p parm]] ,
411: AlgorithmIdentifier [[p (struct alg_id *)0 ]],
412: BIT STRING
413: }
414: }
415: %{
416: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedAddEntryArgument"));
417: %}
418:
419: ChainedAddEntryArgumentData [[P struct ds_op_arg *]]
420: ::=
421: %{
422: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedAddEntryArgumentData"));
423: parm->dca_dsarg.arg_type = OP_ADDENTRY;
424: %}
425: SET
426: {
427: ChainingArgument [[p &(parm->dca_charg)]] ,
428: [0] AddEntryArgument [[p &(parm->dca_dsarg.arg_ad)]]
429: }
430: %{
431: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedAddEntryArgumentData"));
432: %}
433:
434: ChainedAddEntryResult [[P struct ds_op_res *]]
435: ::=
436: %{
437: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedAddEntryResult"));
438: %}
439: CHOICE
440: {
441: ChainedAddEntryResultData [[p parm]] ,
442: SEQUENCE
443: {
444: ChainedAddEntryResultData [[p parm]] ,
445: AlgorithmIdentifier [[p (struct alg_id *)0 ]],
446: BIT STRING
447: }
448: }
449: %{
450: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedAddEntryResult"));
451: %}
452:
453: ChainedAddEntryResultData [[P struct ds_op_res *]]
454: ::=
455: %{
456: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedAddEntryArgumentResultData"));
457: parm->dcr_dsres.result_type = OP_ADDENTRY;
458: %}
459: SET
460: {
461: ChainingResult [[p &(parm->dcr_chres)]] ,
462: [0] AddEntryResult
463: }
464: %{
465: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedAddEntryArgumentResultData"));
466: %}
467:
468: ChainedRemoveEntryArgument [[P struct ds_op_arg *]]
469: ::=
470: %{
471: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedRemoveEntryArgument"));
472: %}
473: CHOICE
474: {
475: ChainedRemoveEntryArgumentData [[p parm]] ,
476: SEQUENCE
477: {
478: ChainedRemoveEntryArgumentData [[p parm]] ,
479: AlgorithmIdentifier [[p (struct alg_id *)0 ]],
480: BIT STRING
481: }
482: }
483: %{
484: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedRemoveEntryArgument"));
485: %}
486:
487: ChainedRemoveEntryArgumentData [[P struct ds_op_arg *]]
488: ::=
489: %{
490: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedRemoveEntryArgumentData"));
491: parm->dca_dsarg.arg_type = OP_REMOVEENTRY;
492: %}
493: SET
494: {
495: ChainingArgument [[p &(parm->dca_charg)]] ,
496: [0] RemoveEntryArgument [[p &(parm->dca_dsarg.arg_rm)]]
497: }
498: %{
499: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedRemoveEntryArgumentData"));
500: %}
501:
502: ChainedRemoveEntryResult [[P struct ds_op_res *]]
503: ::=
504: %{
505: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedRemoveEntryResult"));
506: %}
507: CHOICE
508: {
509: ChainedRemoveEntryResultData [[p parm]] ,
510: SEQUENCE
511: {
512: ChainedRemoveEntryResultData [[p parm]] ,
513: AlgorithmIdentifier [[p (struct alg_id *)0 ]],
514: BIT STRING
515: }
516: }
517: %{
518: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedRemoveEntryResult"));
519: %}
520:
521: ChainedRemoveEntryResultData [[P struct ds_op_res *]]
522: ::=
523: %{
524: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedRemoveEntryResultData"));
525: parm->dcr_dsres.result_type = OP_REMOVEENTRY;
526: %}
527: SET
528: {
529: ChainingResult [[p &(parm->dcr_chres)]] ,
530: [0] RemoveEntryResult
531: }
532: %{
533: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedRemoveEntryResultData"));
534: %}
535:
536: ChainedModifyEntryArgument [[P struct ds_op_arg *]]
537: ::=
538: %{
539: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedModifyEntryArgument"));
540: %}
541: CHOICE
542: {
543: ChainedModifyEntryArgumentData [[p parm]] ,
544: SEQUENCE
545: {
546: ChainedModifyEntryArgumentData [[p parm]] ,
547: AlgorithmIdentifier [[p (struct alg_id *)0 ]],
548: BIT STRING
549: }
550: }
551: %{
552: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedModifyEntryArgument"));
553: %}
554:
555: ChainedModifyEntryArgumentData [[P struct ds_op_arg *]]
556: ::=
557: %{
558: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedModifyEntryArgumentData"));
559: parm->dca_dsarg.arg_type = OP_MODIFYENTRY;
560: %}
561: SET
562: {
563: ChainingArgument [[p &(parm->dca_charg)]] ,
564: [0] ModifyEntryArgument [[p &(parm->dca_dsarg.arg_me)]]
565: }
566: %{
567: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedModifyEntryArgumentData"));
568: %}
569:
570: ChainedModifyEntryResult [[P struct ds_op_res *]]
571: ::=
572: %{
573: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedModifyEntryResult"));
574: %}
575: CHOICE
576: {
577: ChainedModifyEntryResultData [[p parm]] ,
578: SEQUENCE
579: {
580: ChainedModifyEntryResultData [[p parm]] ,
581: AlgorithmIdentifier [[p (struct alg_id *)0 ]],
582: BIT STRING
583: }
584: }
585: %{
586: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedModifyEntryResult"));
587: %}
588:
589: ChainedModifyEntryResultData [[P struct ds_op_res *]]
590: ::=
591: %{
592: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedModifyEntryResultData"));
593: parm->dcr_dsres.result_type = OP_MODIFYENTRY;
594: %}
595: SET
596: {
597: ChainingResult [[p &(parm->dcr_chres)]] ,
598: [0] ModifyEntryResult
599: }
600: %{
601: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedModifyEntryResultData"));
602: %}
603:
604: ChainedModifyRDNArgument [[P struct ds_op_arg *]]
605: ::=
606: %{
607: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedModifyRDNArgument"));
608: %}
609: CHOICE
610: {
611: ChainedModifyRDNArgumentData [[p parm]] ,
612: SEQUENCE
613: {
614: ChainedModifyRDNArgumentData [[p parm]] ,
615: AlgorithmIdentifier [[p (struct alg_id *)0 ]] ,
616: BIT STRING
617: }
618: }
619: %{
620: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedModifyRDNArgument"));
621: %}
622:
623: ChainedModifyRDNArgumentData [[P struct ds_op_arg *]]
624: ::=
625: %{
626: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedModifyRDNArgumentData"));
627: parm->dca_dsarg.arg_type = OP_MODIFYRDN;
628: %}
629: SET
630: {
631: ChainingArgument [[p &(parm->dca_charg)]] ,
632: [0] ModifyRDNArgument [[p &(parm->dca_dsarg.arg_mr)]]
633: }
634: %{
635: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedModifyRDNArgumentData"));
636: %}
637:
638: ChainedModifyRDNResult [[P struct ds_op_res *]]
639: ::=
640: %{
641: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedModifyRDNResult"));
642: %}
643: CHOICE
644: {
645: ChainedModifyRDNResultData [[p parm]] ,
646: SEQUENCE
647: {
648: ChainedModifyRDNResultData [[p parm]] ,
649: AlgorithmIdentifier [[p (struct alg_id *)0 ]] ,
650: BIT STRING
651: }
652: }
653: %{
654: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedModifyRDNResult"));
655: %}
656:
657: ChainedModifyRDNResultData [[P struct ds_op_res *]]
658: ::=
659: %{
660: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedModifyRDNResultData"));
661: parm->dcr_dsres.result_type = OP_MODIFYRDN;
662: %}
663: SET
664: {
665: ChainingResult [[p &(parm->dcr_chres)]] ,
666: [0] ModifyRDNResult
667: }
668: %{
669: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedModifyRDNResultData"));
670: %}
671:
672: DSAReferralParm [[P struct DSE_referral *]]
673: ::=
674: %{
675: DLOG(log_dsap, LLOG_TRACE, ("About to decode DSAReferralParm"));
676: parm->DSE_ref_prefix = NULLDN;
677: parm->DSE_ref_candidates = (ContinuationRef) smalloc(sizeof(continuation_ref));
678: %}
679: SET
680: {
681: [0] ContinuationReference [[p parm->DSE_ref_candidates]] ,
682: contextPrefix
683: [1] DistinguishedName [[p &(parm->DSE_ref_prefix)]]
684: OPTIONAL
685: }
686: %{
687: DLOG(log_dsap, LLOG_TRACE, ("Done decode DSAReferralParm"));
688: %}
689:
690: ChainingArgument [[P struct chain_arg *]]
691: ::=
692: %{
693: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainingArgument"));
694: parm->cha_originator = NULLDN;
695: parm->cha_target = NULLDN;
696: parm->cha_progress.op_resolution_phase = OP_PHASE_NOTSTARTED;
697: parm->cha_progress.op_nextrdntoberesolved = 0;
698: parm->cha_aliasderef = FALSE;
699: parm->cha_aliasedrdns = CA_NO_ALIASDEREFERENCED;
700: parm->cha_returnrefs = FALSE;
701: parm->cha_reftype = RT_SUPERIOR;
702: parm->cha_timelimit = NULLCP;
703: parm->cha_domaininfo = NULLPE;
704: %}
705: SET
706: {
707: originator
708: [0] DistinguishedName [[p &(parm->cha_originator)]]
709: OPTIONAL ,
710: targetObject
711: [1] DistinguishedName [[p &(parm->cha_target)]]
712: OPTIONAL ,
713: operationProgress
714: [2] OperationProgress [[p &(parm->cha_progress)]]
715: -- DEFAULT {notStarted} ,
716: OPTIONAL ,
717: traceInformation
718: [3] TraceInformation [[p &(parm->cha_trace)]] ,
719: aliasDereferenced
720: [4] BOOLEAN [[b parm->cha_aliasderef]]
721: -- DEFAULT FALSE ,
722: OPTIONAL ,
723: aliasedRDNs
724: [5] INTEGER [[i parm->cha_aliasedrdns]]
725: OPTIONAL ,
726: -- absent unless aliasDereferenced is TRUE
727: entryOnly
728: [11] BOOLEAN [[b parm->cha_entryonly]]
729: -- DEFAULT FALSE ,
730: OPTIONAL ,
731: -- absent unless aliasDereferenced is TRUE
732: -- and operation is search, one-level
733: returnCrossRefs
734: [6] BOOLEAN [[b parm->cha_returnrefs]]
735: -- DEFAULT FALSE ,
736: OPTIONAL ,
737: referenceType
738: [7] ReferenceType [[p &(parm->cha_reftype)]]
739: -- DEFAULT superior ,
740: OPTIONAL ,
741: info
742: [8] DomainInfo [[p &(parm->cha_domaininfo)]]
743: OPTIONAL ,
744: timeLimit
745: [9] UTCTime [[s parm->cha_timelimit]]
746: OPTIONAL ,
747: [10] SecurityParameters [[p (struct security_parms **)0 ]]
748: -- DEFAULT {}
749: OPTIONAL
750: }
751: %{
752: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainingArgument"));
753: %}
754:
755: ChainingResult [[P struct chain_res *]]
756: %{
757: struct cross_ref **xrefp;
758: %}
759: ::=
760: %{
761: DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainingResult"));
762: parm->chr_domaininfo = NULLPE;
763: parm->chr_crossrefs = NULLXREF;
764: %}
765: SET
766: {
767: info
768: [0] DomainInfo [[p &(parm->chr_domaininfo)]]
769: OPTIONAL ,
770: crossReferences
771: %{
772: xrefp = &(parm->chr_crossrefs);
773: %}
774: [1] SEQUENCE OF
775: %{
776: (*xrefp) = (struct cross_ref *) smalloc(sizeof(struct cross_ref));
777: %}
778: CrossReference [[p (*xrefp)]]
779: %{
780: xrefp = &((*xrefp)->xref_next);
781: %}
782: %{
783: (*xrefp) = NULLXREF;
784: %}
785: OPTIONAL ,
786: [2] SecurityParameters [[p (struct security_parms **)0 ]]
787: -- DEFAULT {}
788: OPTIONAL
789: }
790: %{
791: DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainingResult"));
792: %}
793:
794: CrossReference [[P struct cross_ref *]]
795: ::=
796: %{
797: DLOG(log_dsap, LLOG_TRACE, ("About to decode CrossReference"));
798: parm->xref_dn = NULLDN;
799: parm->xref_ap = NULLACCESSPOINT;
800: %}
801: SET
802: {
803: contextPrefix
804: [0] DistinguishedName [[p &(parm->xref_dn)]] ,
805: accessPoint
806: [1] AccessPoint [[p parm->xref_ap]]
807: }
808: %{
809: DLOG(log_dsap, LLOG_TRACE, ("Done decode CrossReference"));
810: %}
811:
812: ReferenceType [[P int*]]
813: %{
814: %}
815: ::=
816: %{
817: DLOG(log_dsap, LLOG_TRACE, ("About to decode ReferenceType"));
818: %}
819: ENUMERATED [[i (*parm)]]
820: {
821: superior(1) ,
822: subordinate(2) ,
823: cross(3) ,
824: nonSpecificSubordinate(4)
825: }
826: %{
827: DLOG(log_dsap, LLOG_TRACE, ("Done decode ReferenceType"));
828: %}
829:
830: TraceInformation [[P struct trace_info **]]
831: %{
832: struct trace_info **tip;
833: %}
834: ::=
835: %{
836: DLOG(log_dsap, LLOG_TRACE, ("About to decode TraceInformation"));
837: (*parm) = NULLTRACEINFO;
838: tip = parm;
839: %}
840: SEQUENCE OF
841: %{
842: (*tip) = (struct trace_info *) malloc(sizeof(struct trace_info));
843: %}
844: TraceItem [[p (*tip)]]
845: %{
846: tip = &((*tip)->ti_next);
847: %}
848: %{
849: (*tip) = NULLTRACEINFO;
850: DLOG(log_dsap, LLOG_TRACE, ("Done decode TraceInformation"));
851: %}
852:
853: TraceItem [[P struct trace_info *]]
854: ::=
855: %{
856: DLOG(log_dsap, LLOG_TRACE, ("About to decode TraceItem"));
857: parm->ti_dsa = NULLDN;
858: parm->ti_target = NULLDN;
859: %}
860: SET
861: {
862: dsa
863: [0] Name [[p &(parm->ti_dsa)]] ,
864: targetObject
865: [1] Name [[p &(parm->ti_target)]]
866: OPTIONAL ,
867: operationProgress
868: [2] OperationProgress [[p &(parm->ti_progress)]]
869: }
870: %{
871: DLOG(log_dsap, LLOG_TRACE, ("Done decode TraceItem"));
872: %}
873:
874: OperationProgress [[P struct op_progress *]]
875: %{
876: int phase;
877: %}
878: ::=
879: %{
880: DLOG(log_dsap, LLOG_TRACE, ("About to decode OperationProgress"));
881: parm->op_resolution_phase = 0;
882: parm->op_nextrdntoberesolved = 0;
883: %}
884: SET
885: {
886: nameResolutionPhase
887: [0] ENUMERATED [[i phase]]
888: {
889: notStarted(1) ,
890: proceeding(2) ,
891: completed(3)
892: }
893: %{
894: parm->op_resolution_phase = phase - 1;
895: %} ,
896: nextRDNToBeResolved
897: [1] INTEGER [[i parm->op_nextrdntoberesolved]]
898: %{
899: %}
900: OPTIONAL
901: }
902: %{
903: DLOG(log_dsap, LLOG_TRACE, ("Done decode OperationProgress"));
904: %}
905:
906: DomainInfo [[P PE *]]
907: %{
908: PE old_pe;
909: %}
910: ::=
911: %{
912: DLOG(log_dsap, LLOG_TRACE, ("About to decode DomainInfo"));
913: %}
914: ANY [[a old_pe]]
915: %{
916: (*parm) = old_pe;
917: DLOG(log_dsap, LLOG_TRACE, ("Done decode DomainInfo"));
918: %}
919:
920: ContinuationReference [[P struct continuation_ref *]]
921: %{
922: struct access_point **app;
923: %}
924: ::=
925: %{
926: DLOG(log_dsap, LLOG_TRACE, ("About to decode ContinuationReference"));
927: parm->cr_name = NULLDN;
928: parm->cr_aliasedRDNs = CR_NOALIASEDRDNS;
929: parm->cr_rdn_resolved = CR_RDNRESOLVED_NOTDEFINED;
930: parm->cr_reftype = RT_UNDEFINED;
931: parm->cr_next = NULLCONTINUATIONREF;
932: parm->cr_accesspoints = NULLACCESSPOINT;
933: app = &(parm->cr_accesspoints);
934: %}
935: SET
936: {
937: targetObject
938: [0] Name [[p &(parm->cr_name)]]
939: %{
940: %} ,
941: aliasedRDNs
942: [1] INTEGER [[i parm->cr_aliasedRDNs]]
943: %{
944: %}
945: OPTIONAL ,
946: operationProgress
947: [2] OperationProgress [[p &(parm->cr_progress)]]
948: %{
949: %} ,
950: rdnsResolved
951: [3] INTEGER [[i parm->cr_rdn_resolved]]
952: %{
953: %}
954: OPTIONAL ,
955: referenceType
956: [4] ReferenceType [[p &(parm->cr_reftype)]]
957: %{
958: %}
959: OPTIONAL ,
960: accessPoints
961: [5] SET OF
962: %{
963: (*app) = (struct access_point *) smalloc(sizeof(struct access_point));
964: %}
965: AccessPoint [[p (*app)]]
966: %{
967: app = &((*app)->ap_next);
968: %}
969: %{
970: (*app) = NULLACCESSPOINT;
971: %}
972: }
973: %{
974: DLOG(log_dsap, LLOG_TRACE, ("Done decode ContinuationReference"));
975: %}
976:
977: AccessPoint [[P struct access_point *]]
978: %{
979: %}
980: ::=
981: %{
982: DLOG(log_dsap, LLOG_TRACE, ("About to decode AccessPoint"));
983: parm->ap_name = NULLDN;
984: parm->ap_next = NULLACCESSPOINT;
985: parm->ap_address = (struct PSAPaddr *) smalloc(sizeof(struct PSAPaddr));
986: %}
987: SET
988: {
989: [0] Name [[p &(parm->ap_name)]]
990: %{
991: %} ,
992: [1] ISODEPresentationAddress [[p parm->ap_address]]
993: %{
994: %}
995: }
996: %{
997: DLOG(log_dsap, LLOG_TRACE, ("Done decode AccessPoint"));
998: %}
999:
1000: ISODEPresentationAddress [[P struct PSAPaddr * ]]
1001: ::=
1002: %{
1003: DLOG(log_dsap, LLOG_TRACE, ("About to decode PresentationAddress"));
1004: %}
1005: DSE.PSAPaddr [[p parm]]
1006: %{
1007: DLOG(log_dsap, LLOG_TRACE, ("Done decode PresentationAddress"));
1008: %}
1009:
1010: InvokeID [[P int*]]
1011: %{
1012: %}
1013: ::=
1014: %{
1015: DLOG(log_dsap, LLOG_TRACE, ("About to decode InvokeID"));
1016: %}
1017: INTEGER [[i (*parm)]]
1018: %{
1019: DLOG(log_dsap, LLOG_TRACE, ("Done decode InvokeID"));
1020: %}
1021:
1022: END
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.