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