1InfObj DEFINITIONS ::= 2BEGIN 3 4 5RANAP-ELEMENTARY-PROCEDURE ::= CLASS { 6 &InitiatingMessage , 7 &SuccessfulOutcome OPTIONAL, 8 &Outcome DEFAULT NULL, 9 &vartypvalue &Outcome OPTIONAL, 10 &FixTypeValSet PrintableString OPTIONAL, 11 &VarTypeValSet &InitiatingMessage OPTIONAL, 12 &infoObject RANAP-ELEMENTARY-PROCEDURE OPTIONAL, 13 &InfObjectSet CLASS2 OPTIONAL, 14 &UnsuccessfulOutcome OPTIONAL, 15 &procedureCode ProcedureCode UNIQUE, 16 &criticality Criticality DEFAULT ignore 17} 18WITH SYNTAX { 19 INITIATING MESSAGE &InitiatingMessage 20 [SUCCESSFUL OUTCOME &SuccessfulOutcome] 21 [UNSUCCESSFUL OUTCOME &UnsuccessfulOutcome] 22 [OUTCOME &Outcome] 23 PROCEDURE CODE &procedureCode 24 [CRITICALITY &criticality] 25 [VARTYPEVALUE &vartypvalue] 26 [FIXT &FixTypeValSet] 27 [VART &VarTypeValSet] 28 [INFOOBJECT &infoObject] 29 [INFOOBJECTSET &InfObjectSet] 30} 31 32RANAP-PDU ::= CHOICE { 33 initiatingMessage InitiatingMessage, 34-- successfulOutcome SuccessfulOutcome, 35-- unsuccessfulOutcome UnsuccessfulOutcome, 36-- outcome Outcome, 37 ... 38} 39 40CLASS2 ::= RANAP-ELEMENTARY-PROCEDURE 41 42InitiatingMessage ::= SEQUENCE { 43 procedureCode RANAP-ELEMENTARY-PROCEDURE.&procedureCode ({RANAP-ELEMENTARY-PROCEDURES}), 44 criticality RANAP-ELEMENTARY-PROCEDURE.&criticality ({RANAP-ELEMENTARY-PROCEDURES}{@procedureCode}), 45 value RANAP-ELEMENTARY-PROCEDURE.&InitiatingMessage ({RANAP-ELEMENTARY-PROCEDURES}{@procedureCode}) 46 } 47 48iu-Release RANAP-ELEMENTARY-PROCEDURE ::= { 49 INITIATING MESSAGE Iu-ReleaseCommand 50 SUCCESSFUL OUTCOME Iu-ReleaseComplete 51 PROCEDURE CODE id-Iu-Release1 52 CRITICALITY ignore 53 } 54 55relocationPreparation RANAP-ELEMENTARY-PROCEDURE ::= { 56 INITIATING MESSAGE INTEGER --Iu-ReleaseCommand 57 SUCCESSFUL OUTCOME Iu-ReleaseComplete 58 PROCEDURE CODE id-Iu-Release2 59 CRITICALITY notify 60 } 61 62object3 RANAP-ELEMENTARY-PROCEDURE ::= { 63 &InitiatingMessage Iu-ReleaseCommand, 64 &SuccessfulOutcome Iu-ReleaseComplete, 65 &procedureCode id-Iu-Release3, 66 &criticality reject 67 } 68 69object4 RANAP-ELEMENTARY-PROCEDURE ::= { 70 &InitiatingMessage INTEGER, 71 &SuccessfulOutcome PrintableString, 72 &procedureCode id-Iu-Release4, 73 &criticality reject 74 } 75 76object5 RANAP-ELEMENTARY-PROCEDURE ::= { 77 &InitiatingMessage INTEGER, 78 &SuccessfulOutcome PrintableString, 79 &Outcome ProcedureCode, 80 &vartypvalue 12, 81 &infoObject object4, 82 &InfObjectSet MyObjectSet, 83 &procedureCode id-Iu-Release5, 84 &criticality reject 85 } 86 87 88RANAP-ELEMENTARY-PROCEDURES RANAP-ELEMENTARY-PROCEDURE ::= { 89 iu-Release | 90 relocationPreparation , 91 ... 92 } 93 94RANAP-ELEMENTARY-PROCEDURES2 RANAP-ELEMENTARY-PROCEDURE ::= { 95 iu-Release | 96 relocationPreparation 97 } 98 99 100OBJECTSET1 RANAP-ELEMENTARY-PROCEDURE ::= { 101 {INITIATING MESSAGE Iu-ReleaseCommand SUCCESSFUL OUTCOME Iu-ReleaseComplete PROCEDURE CODE id-Iu-Release1 CRITICALITY ignore} | {INITIATING MESSAGE Iu-ReleaseCommand PROCEDURE CODE id-Iu-Release2} 102 } 103 104OBJECTSET2 RANAP-ELEMENTARY-PROCEDURE ::= { 105 iu-Release | 106 {INITIATING MESSAGE Iu-ReleaseCommand SUCCESSFUL OUTCOME Iu-ReleaseComplete PROCEDURE CODE id-Iu-Release4 CRITICALITY ignore} | 107 relocationPreparation | 108 {INITIATING MESSAGE Iu-ReleaseCommand PROCEDURE CODE id-Iu-Release5} , 109 ... 110 } 111 112OBJECTSET3 RANAP-ELEMENTARY-PROCEDURE ::= { 113 iu-Release, 114 ... 115 } 116 117OBJECTSET4 RANAP-ELEMENTARY-PROCEDURE ::= { 118 iu-Release 119 } 120 121Iu-ReleaseCommand ::= SEQUENCE { 122 first INTEGER, 123 second BOOLEAN 124 } 125 126Iu-ReleaseComplete ::= INTEGER (1..510) 127 128ProcedureCode ::= INTEGER (0..255) 129Criticality ::= ENUMERATED { reject, ignore, notify } 130id-Iu-Release1 INTEGER ::= 1 131id-Iu-Release2 INTEGER ::= 2 132id-Iu-Release3 INTEGER ::= 3 133id-Iu-Release4 INTEGER ::= 4 134id-Iu-Release5 INTEGER ::= 5 135 136-- 137-- MY-CLASS 138-- 139 140Seq ::= SEQUENCE { 141 int INTEGER, 142 str OCTET STRING 143} 144 145MY-CLASS ::= CLASS { 146 &Count DEFAULT INTEGER, 147 &integerValue INTEGER UNIQUE, 148 &booleanValue BOOLEAN, 149 &stringValue PrintableString 150} 151 152myobject MY-CLASS ::= { 153 &integerValue 12, 154 &booleanValue TRUE, 155 &stringValue "hejsan" 156} 157 158myotherobject MY-CLASS ::= { 159 &Count Seq, 160 &integerValue 42, 161 &booleanValue FALSE, 162 &stringValue "hoppsan" 163} 164 165MyObjectSet MY-CLASS ::= { 166 myobject | myotherobject | 167 { 168 -- Each character will be encoded in 3 bits in UPER, 4 bits in PER. 169 &Count NumericString (FROM("01234567") ^ SIZE(8)), 170 &integerValue 43, 171 &booleanValue TRUE, 172 &stringValue "tjosan" 173 } 174} 175 176MyPdu ::= SEQUENCE { 177 count MY-CLASS.&Count ({MyObjectSet}{@int}), 178 int MY-CLASS.&integerValue ({MyObjectSet}), 179 bool MY-CLASS.&booleanValue ({MyObjectSet}{@int}), 180 str MY-CLASS.&stringValue ({MyObjectSet}{@int}) 181} 182 183Seq2 ::= SEQUENCE { 184 int MY-CLASS.&integerValue ({MyObjectSet}), 185 seqof SEQUENCE (1..10) OF MY-CLASS.&booleanValue ({MyObjectSet}{@int}), 186 setof SET (1..10) OF MY-CLASS.&booleanValue ({MyObjectSet}{@int}) 187} 188 189-- 190-- Class with constructed default 191-- 192 193CONSTRUCTED-DEFAULT ::= CLASS { 194 &id INTEGER UNIQUE, 195 &Type DEFAULT SEQUENCE { a INTEGER, b BOOLEAN }, 196 &ok BOOLEAN DEFAULT TRUE 197} 198 199constructed1 CONSTRUCTED-DEFAULT ::= { &id 1 } 200constructed2 CONSTRUCTED-DEFAULT ::= { &id 2, &ok false } 201 202ConstructedDefaultSet CONSTRUCTED-DEFAULT ::= { 203 constructed1 | 204 constructed2 | 205 { &id 3, &Type BOOLEAN } | 206 { &id 4, &Type SET { a INTEGER, b BIT STRING } } | 207 { &id 5, &Type CHOICE { i INTEGER, b BIT STRING } } | 208 { &id 6, &Type SEQUENCE OF INTEGER (1..16) } | 209 { &id 7, &Type SET OF INTEGER (1..64) } | 210 { &id 8, &Type SEQUENCE OF SEQUENCE { x INTEGER, y INTEGER } } | 211 { &id 9, &Type SET OF SEQUENCE { x INTEGER, y INTEGER } } 212} 213 214ConstructedPdu ::= SEQUENCE { 215 id CONSTRUCTED-DEFAULT.&id ({ConstructedDefaultSet}), 216 content CONSTRUCTED-DEFAULT.&Type ({ConstructedDefaultSet}{@id}) 217} 218 219ConstructedSet ::= SET { 220 id [0] CONSTRUCTED-DEFAULT.&id ({ConstructedDefaultSet}), 221 content [1] CONSTRUCTED-DEFAULT.&Type ({ConstructedDefaultSet}{@id}) 222} 223 224-- Test OPTIONAL and DEFAULT 225 226OptionalInSeq ::= SEQUENCE { 227 id CONSTRUCTED-DEFAULT.&id ({ConstructedDefaultSet}), 228 content CONSTRUCTED-DEFAULT.&Type ({ConstructedDefaultSet}{@id}) OPTIONAL 229} 230 231DefaultInSeq ::= SEQUENCE { 232 id CONSTRUCTED-DEFAULT.&id ({ConstructedDefaultSet}), 233 content CONSTRUCTED-DEFAULT.&Type ({ConstructedDefaultSet}{@id}) 234 DEFAULT BOOLEAN:TRUE 235} 236 237-- Test more than one optional typefield table constraint in a SEQUENCE. 238 239MULTIPLE-OPTIONALS ::= CLASS { 240 &id INTEGER UNIQUE, 241 &T1, 242 &T2, 243 &T3 244} 245 246multiple-optionals-1 MULTIPLE-OPTIONALS ::= 247 {&id 1, &T1 INTEGER, &T2 BOOLEAN, &T3 OCTET STRING} 248 249Multiple-Optionals-Set MULTIPLE-OPTIONALS ::= { 250 multiple-optionals-1 251} 252 253Multiple-Optionals ::= SEQUENCE { 254 id MULTIPLE-OPTIONALS.&id ({Multiple-Optionals-Set}), 255 t1 [0] MULTIPLE-OPTIONALS.&T1 ({Multiple-Optionals-Set}{@id}) OPTIONAL, 256 t2 [1] MULTIPLE-OPTIONALS.&T2 ({Multiple-Optionals-Set}{@id}) OPTIONAL, 257 t3 [2] MULTIPLE-OPTIONALS.&T3 ({Multiple-Optionals-Set}{@id}) OPTIONAL 258} 259 260-- Test different ways of constructing object sets. 261 262OBJECT-SET-TEST ::= CLASS { 263 &id INTEGER UNIQUE, 264 &Type 265} WITH SYNTAX { 266 &id IS &Type 267} 268 269ObjectSetTest{OBJECT-SET-TEST:ObjectSet} ::= 270 SEQUENCE { 271 id OBJECT-SET-TEST.&id ({ObjectSet}), 272 type OBJECT-SET-TEST.&Type ({ObjectSet}{@id}) 273 } 274 275ost1 OBJECT-SET-TEST ::= { 1 IS BIT STRING } 276ost2 OBJECT-SET-TEST ::= { 2 IS OCTET STRING } 277ost3 OBJECT-SET-TEST ::= { 3 IS ENUMERATED {donald,scrooge} } 278ost4 OBJECT-SET-TEST ::= { 4 IS BOOLEAN } 279ost5 OBJECT-SET-TEST ::= { 5 IS INTEGER (0..15) } 280 281Ost12 OBJECT-SET-TEST ::= { ost1 | ost2 } 282Ost123 OBJECT-SET-TEST ::= { ost3 | Ost12 } 283Ost1234 OBJECT-SET-TEST ::= { Ost123 | ost4 } 284Ost45 OBJECT-SET-TEST ::= { ost4 | ost5 } 285Ost12345 OBJECT-SET-TEST ::= { Ost123 | Ost45 } 286 287OstSeq12 ::= ObjectSetTest{ {Ost12} } 288OstSeq123 ::= ObjectSetTest{ {Ost123} } 289OstSeq1234 ::= ObjectSetTest{ {Ost1234} } 290OstSeq45 ::= ObjectSetTest{ {Ost45} } 291OstSeq12345 ::= ObjectSetTest{ {Ost12345} } 292 293OstSeq12Except ::= ObjectSetTest{ {Ost123 EXCEPT ost3} } 294OstSeq123Except ::= ObjectSetTest{ {Ost12345 EXCEPT Ost45} } 295 296ExOst1 OBJECT-SET-TEST ::= { ost1, ... } 297ExOst12 OBJECT-SET-TEST ::= { ost1, ..., ost2 } 298ExOst123 OBJECT-SET-TEST ::= { ost3, ..., ExOst12 } 299ExOst1234 OBJECT-SET-TEST ::= { ExOst123, ..., ost4 } 300ExOst45 OBJECT-SET-TEST ::= { ost4, ..., ost5 } 301ExOst12345 OBJECT-SET-TEST ::= { ExOst123, ..., ExOst45 } 302 303ExOstSeq1 ::= ObjectSetTest{ {ExOst1} } 304ExOstSeq12 ::= ObjectSetTest{ {ExOst12} } 305ExOstSeq123 ::= ObjectSetTest{ {ExOst123} } 306ExOstSeq1234 ::= ObjectSetTest{ {ExOst1234} } 307ExOstSeq45 ::= ObjectSetTest{ {ExOst45} } 308ExOstSeq12345 ::= ObjectSetTest{ {ExOst12345} } 309 310ExOstSeq12Except ::= ObjectSetTest{ {ExOst123 EXCEPT ost3} } 311ExOstSeq123Except ::= ObjectSetTest{ {ExOst12345 EXCEPT ExOst45} } 312 313ExInlOst1 OBJECT-SET-TEST ::= { 314 { 1 IS BIT STRING }, 315 ... 316} 317ExInlOst12 OBJECT-SET-TEST ::= { 318 { 1 IS BIT STRING }, 319 ..., 320 { 2 IS OCTET STRING } 321} 322 323ExInlOstSeq1 ::= ObjectSetTest{ {ExInlOst1} } 324ExInlOstSeq12 ::= ObjectSetTest{ {ExInlOst12} } 325 326-- 327-- Test that extensions in a simple class works. 328-- 329 330ExtClassSeq ::= SEQUENCE { 331 arg EXT-CLASS.&id({Extend}) 332} 333 334EXT-CLASS ::= CLASS { 335 &id INTEGER UNIQUE 336} WITH SYNTAX { 337 ID &id 338} 339 340Extend EXT-CLASS ::= { { ID alt1 } | { ID alt2 }, ... } 341 342alt1 INTEGER ::= 4 343alt2 INTEGER ::= 5 344 345 346-- 347-- Test a BIT STRING which is optional in the simplified syntax. 348-- 349 350PUBLIC-KEY ::= CLASS { 351 &id INTEGER UNIQUE, 352 &keyUsage KeyUsage OPTIONAL 353} WITH SYNTAX { 354 IDENTIFIER &id 355 [OPTIONAL-BIT-STRING &keyUsage] 356} 357 358KeyUsage ::= BIT STRING { 359 digitalSignature (0), 360 nonRepudiation (1), 361 keyEncipherment (2) 362 } 363 364object-with-optional-bit-string PUBLIC-KEY ::= { 365 IDENTIFIER 42 366 OPTIONAL-BIT-STRING {digitalSignature, nonRepudiation, keyEncipherment} 367} 368 369-- Test object identifiers from objects. 370 371CONTAINER ::= CLASS { 372 &id OBJECT IDENTIFIER UNIQUE, 373 &rid RELATIVE-OID OPTIONAL, 374 &Type OPTIONAL 375} WITH SYNTAX { 376 IDENTIFIED BY &id 377 [REL-OID &rid] 378 [TYPE &Type] 379} 380 381id1 OBJECT IDENTIFIER ::= {1 2 42} 382obj1 CONTAINER ::= { IDENTIFIED BY id1 REL-OID {100 101} } 383 384value-2 OBJECT IDENTIFIER ::= { value-1 25 } 385value-1 OBJECT IDENTIFIER ::= obj1.&id 386value-3 RELATIVE-OID ::= obj1.&rid 387value-4 OBJECT IDENTIFIER ::= { 1 2 value-3 } 388 389 390-- Test an obscure issue when ATTRIBUTE.&id was not 391-- properly evaluated. 392 393Rdn ::= SingleAttribute { {SupportedAttributes} } 394 395ATTRIBUTE ::= CLASS { 396 &id OBJECT IDENTIFIER UNIQUE, 397 &Type OPTIONAL 398} 399 400SingleAttribute{ATTRIBUTE:AttrSet} ::= SEQUENCE { 401 type ATTRIBUTE.&id({AttrSet}), 402 value ATTRIBUTE.&Type({AttrSet}{@type}) 403} 404 405AttributeType ::= ATTRIBUTE.&id 406 407SupportedAttributes ATTRIBUTE ::= { at-name } 408 409id-at OBJECT IDENTIFIER ::= { 2 5 4 41 } 410id-at-name AttributeType ::= id-at 411at-name ATTRIBUTE ::= { &Type PrintableString, &id id-at-name } 412 413-- 414-- Test using an alias for TYPE-IDENTIFIER. 415-- 416 417TiAliasParameterized { TI-ALIAS:InfoObjectSet } ::= SEQUENCE { 418 algorithm TI-ALIAS.&id({InfoObjectSet}), 419 parameters TI-ALIAS.&Type({InfoObjectSet} {@algorithm}) OPTIONAL 420} 421 422TI-ALIAS ::= TYPE-IDENTIFIER 423 424TiAliasSeq ::= SEQUENCE { 425 prf TiAliasParameterized {{TiAliasSet}} 426} 427 428TiAliasSet TI-ALIAS ::= { 429 {NULL IDENTIFIED BY {2 1 2}}, 430 ... 431} 432 433-- 434-- Test using an alias for a class. 435-- 436 437ALIAS-CONTAINER ::= CLASS { 438 &id INTEGER UNIQUE, 439 &obj INDIRECT-CLASS 440} 441 442INDIRECTED-CLASS ::= CLASS { 443 &id INTEGER UNIQUE, 444 &Type 445} 446 447INDIRECT-CLASS ::= INDIRECTED-CLASS 448 449-- 450-- Indirect ObjectClassFieldType in a SEQUENCE. 451-- 452 453ContentInfo ::= SEQUENCE { 454 contentType ContentType, -- Indirect ObjectClassFieldType 455 content TYPE-IDENTIFIER.&Type({Contents}{@contentType}) 456OPTIONAL 457} 458 459Contents TYPE-IDENTIFIER ::= { 460 {IA5String IDENTIFIED BY id-content-type} 461} 462 463ContentType ::= TYPE-IDENTIFIER.&id({Contents}) 464id-content-type ContentType ::= { 2 7 8 9 } 465 466-- 467-- Tricky parsing of simplified syntax. 468-- 469 470TrickyType-1 ::= BIT STRING 471TrickyType-2 ::= OCTET STRING 472 473TRICKY ::= CLASS { 474 &Type1, 475 &Type2 476} WITH SYNTAX { 477 TYPE &Type1 &Type2 478} 479 480tricky-object TRICKY ::= {TYPE TrickyType-1 TrickyType-2} 481 482tricky-bit-string tricky-object.&Type1 ::= '1011'B 483tricky-octet-string tricky-object.&Type1 ::= 'CAFE'H 484 485END 486