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