Annotation of 43BSDReno/contrib/isode-beta/dsap/x500as/do-enc.py, revision 1.1

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

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.