a31db2af0d
Prior to this commit only those C structs for SET and SEQUENCE types could be decorated. Now those for CHOICE types also can be decorated. We could further extend this to SET OF and SEQUENCE OF types if it proves useful.
310 lines
7.8 KiB
Groff
310 lines
7.8 KiB
Groff
-- $Id$ --
|
|
|
|
TEST DEFINITIONS ::=
|
|
|
|
BEGIN
|
|
|
|
IMPORTS HEIM_ANY FROM heim;
|
|
|
|
-- Check that we handle out of order definitions.
|
|
-- The compiler should emit the definition of TESTOutOfOrderBar before that of
|
|
-- TESTOutOfOrderFoo.
|
|
TESTOutOfOrderFoo ::= SEQUENCE {
|
|
bar TESTOutOfOrderBar
|
|
}
|
|
|
|
TESTOutOfOrderBar ::= SEQUENCE {
|
|
aMember INTEGER
|
|
}
|
|
|
|
-- Check that we can handle rpc.mountd style "lists". This is unnecessarily
|
|
-- inefficient in its encoding, and there's no point to using this over
|
|
-- SEQUENCE OF (arrays), but it's neat that we can do this now that we can do
|
|
-- out of order definitions.
|
|
--
|
|
-- This could be useful if we ever extend asn1_compile to also handle XDR,
|
|
-- which we well might since XDR's syntax is a dual of a strict subset of
|
|
-- ASN.1, and since XDR the encoding is fairly straightforward.
|
|
--
|
|
-- Note that the `next' member has to be OPTIONAL for this to work.
|
|
TESTCircular ::= SEQUENCE {
|
|
name UTF8String,
|
|
next TESTCircular OPTIONAL
|
|
}
|
|
|
|
TESTDefault ::= SEQUENCE {
|
|
name UTF8String DEFAULT "Heimdal",
|
|
version [0] TESTuint32 DEFAULT 8,
|
|
maxint TESTuint64 DEFAULT 9223372036854775807,
|
|
works BOOLEAN DEFAULT TRUE
|
|
}
|
|
|
|
TESTuint32 ::= INTEGER (0..4294967295)
|
|
TESTuint64 ::= INTEGER(0..9223372036854775807)
|
|
TESTint64 ::= INTEGER(-9223372036854775808..9223372036854775807)
|
|
|
|
TESTLargeTag ::= SEQUENCE {
|
|
foo[127] INTEGER (-2147483648..2147483647),
|
|
bar[128] INTEGER (-2147483648..2147483647)
|
|
}
|
|
|
|
TESTSeq ::= SEQUENCE {
|
|
tag0[0] INTEGER (-2147483648..2147483647),
|
|
tag1[1] TESTLargeTag,
|
|
tagless INTEGER (-2147483648..2147483647),
|
|
tag3[2] INTEGER (-2147483648..2147483647)
|
|
}
|
|
|
|
TESTChoice1 ::= CHOICE {
|
|
i1[1] INTEGER (-2147483648..2147483647),
|
|
i2[2] INTEGER (-2147483648..2147483647),
|
|
...
|
|
}
|
|
|
|
TESTChoice2 ::= CHOICE {
|
|
i1[1] INTEGER (-2147483648..2147483647),
|
|
...
|
|
}
|
|
|
|
TESTInteger ::= INTEGER (-2147483648..2147483647)
|
|
|
|
TESTInteger2 ::= [4] IMPLICIT TESTInteger
|
|
TESTInteger3 ::= [5] IMPLICIT TESTInteger2
|
|
|
|
TESTImplicit ::= SEQUENCE {
|
|
ti1[0] IMPLICIT INTEGER (-2147483648..2147483647),
|
|
ti2[1] IMPLICIT SEQUENCE {
|
|
foo[127] INTEGER (-2147483648..2147483647)
|
|
},
|
|
ti3[2] IMPLICIT [5] IMPLICIT [4] IMPLICIT INTEGER (-2147483648..2147483647)
|
|
}
|
|
|
|
TESTImplicit2 ::= SEQUENCE {
|
|
ti1[0] IMPLICIT TESTInteger,
|
|
-- ti2[1] IMPLICIT TESTLargeTag, this is disabled since the IMPLICT encoder does't get the types right when stepping inside an structure --
|
|
ti3[2] IMPLICIT TESTInteger3,
|
|
ti4[51] IMPLICIT TESTInteger OPTIONAL
|
|
}
|
|
|
|
TESTImplicit3 ::= CHOICE {
|
|
ti1[0] IMPLICIT INTEGER (-2147483648..2147483647),
|
|
ti2[5] IMPLICIT CHOICE { i1[1] INTEGER (-2147483648..2147483647) }
|
|
}
|
|
|
|
TESTImplicit4 ::= CHOICE {
|
|
ti1[0] IMPLICIT INTEGER (-2147483648..2147483647),
|
|
ti2[5] IMPLICIT TESTChoice2
|
|
}
|
|
|
|
TESTAllocInner ::= SEQUENCE {
|
|
ai[0] TESTInteger
|
|
}
|
|
|
|
TESTAlloc ::= SEQUENCE {
|
|
tagless TESTAllocInner OPTIONAL,
|
|
three [1] INTEGER (-2147483648..2147483647),
|
|
tagless2 HEIM_ANY OPTIONAL
|
|
}
|
|
|
|
TESTOptional ::= SEQUENCE {
|
|
zero [0] INTEGER (-2147483648..2147483647) OPTIONAL,
|
|
one [1] INTEGER (-2147483648..2147483647) OPTIONAL
|
|
}
|
|
|
|
|
|
TESTCONTAINING ::= OCTET STRING ( CONTAINING INTEGER )
|
|
TESTENCODEDBY ::= OCTET STRING ( ENCODED BY
|
|
{ joint-iso-itu-t(2) asn(1) ber-derived(2) distinguished-encoding(1) }
|
|
)
|
|
|
|
testDer OBJECT IDENTIFIER ::= {
|
|
joint-iso-itu-t(2) asn(1) ber-derived(2) distinguished-encoding(1)
|
|
}
|
|
|
|
testContainingEncodedBy ::= OCTET STRING ( CONTAINING INTEGER ENCODED BY
|
|
{ joint-iso-itu-t(2) asn(1) ber-derived(2) distinguished-encoding(1) }
|
|
)
|
|
|
|
testContainingEncodedBy2 ::= OCTET STRING (
|
|
CONTAINING INTEGER ENCODED BY testDer
|
|
)
|
|
|
|
|
|
testValue1 INTEGER ::= 1
|
|
|
|
testUserConstrained ::= OCTET STRING (CONSTRAINED BY { -- meh -- })
|
|
-- TESTUSERCONSTRAINED2 ::= OCTET STRING (CONSTRAINED BY { TESTInteger })
|
|
-- TESTUSERCONSTRAINED3 ::= OCTET STRING (CONSTRAINED BY { INTEGER })
|
|
-- TESTUSERCONSTRAINED4 ::= OCTET STRING (CONSTRAINED BY { INTEGER : 1 })
|
|
|
|
TESTSeqOf ::= SEQUENCE OF TESTInteger
|
|
|
|
TESTSeqSizeOf1 ::= SEQUENCE SIZE (2) OF TESTInteger
|
|
TESTSeqSizeOf2 ::= SEQUENCE SIZE (1..2) OF TESTInteger
|
|
TESTSeqSizeOf3 ::= SEQUENCE SIZE (1..MAX) OF TESTInteger
|
|
TESTSeqSizeOf4 ::= SEQUENCE SIZE (0..2) OF TESTInteger
|
|
|
|
TESTOSSize1 ::= OCTET STRING SIZE (1..2)
|
|
|
|
TESTSeqOfSeq ::= SEQUENCE OF SEQUENCE {
|
|
zero [0] TESTInteger
|
|
}
|
|
|
|
TESTSeqOfSeq2 ::= SEQUENCE OF SEQUENCE {
|
|
string [0] GeneralString
|
|
}
|
|
|
|
TESTSeqOfSeq3 ::= SEQUENCE OF SEQUENCE {
|
|
zero [0] TESTInteger,
|
|
string [0] GeneralString
|
|
}
|
|
|
|
TESTSeqOf2 ::= SEQUENCE {
|
|
strings SEQUENCE OF GeneralString
|
|
}
|
|
|
|
TESTSeqOf3 ::= SEQUENCE {
|
|
strings SEQUENCE OF GeneralString OPTIONAL
|
|
}
|
|
|
|
-- Larger/more complex to increase odds of out-of-bounds
|
|
-- read/writes if miscoded
|
|
|
|
TESTSeqOf4 ::= SEQUENCE {
|
|
b1 [0] SEQUENCE OF SEQUENCE {
|
|
s1 OCTET STRING,
|
|
s2 OCTET STRING,
|
|
u1 TESTuint64,
|
|
u2 TESTuint64
|
|
} OPTIONAL,
|
|
b2 [1] IMPLICIT SEQUENCE OF SEQUENCE {
|
|
u1 TESTuint64,
|
|
u2 TESTuint64,
|
|
u3 TESTuint64,
|
|
s1 OCTET STRING,
|
|
s2 OCTET STRING,
|
|
s3 OCTET STRING
|
|
} OPTIONAL,
|
|
b3 [2] IMPLICIT SEQUENCE OF SEQUENCE {
|
|
s1 OCTET STRING,
|
|
u1 TESTuint64,
|
|
s2 OCTET STRING,
|
|
u2 TESTuint64,
|
|
s3 OCTET STRING,
|
|
u3 TESTuint64,
|
|
s4 OCTET STRING,
|
|
u4 TESTuint64
|
|
} OPTIONAL
|
|
}
|
|
|
|
TESTSeqOf5 ::= SEQUENCE {
|
|
outer SEQUENCE {
|
|
inner SEQUENCE {
|
|
u0 TESTuint64,
|
|
s0 OCTET STRING,
|
|
u1 TESTuint64,
|
|
s1 OCTET STRING,
|
|
u2 TESTuint64,
|
|
s2 OCTET STRING,
|
|
u3 TESTuint64,
|
|
s3 OCTET STRING,
|
|
u4 TESTuint64,
|
|
s4 OCTET STRING,
|
|
u5 TESTuint64,
|
|
s5 OCTET STRING,
|
|
u6 TESTuint64,
|
|
s6 OCTET STRING,
|
|
u7 TESTuint64,
|
|
s7 OCTET STRING
|
|
}
|
|
}
|
|
OPTIONAL
|
|
}
|
|
|
|
TESTPreserve ::= SEQUENCE {
|
|
zero [0] TESTInteger,
|
|
one [1] TESTInteger
|
|
}
|
|
|
|
TESTBitString ::= BIT STRING {
|
|
zero(0),
|
|
eight(8),
|
|
thirtyone(31)
|
|
}
|
|
|
|
TESTBitString64 ::= BIT STRING {
|
|
zero(0),
|
|
eight(8),
|
|
thirtyone(31),
|
|
thirtytwo(32),
|
|
sixtythree(63)
|
|
}
|
|
|
|
TESTLargeBitString ::= BIT STRING {
|
|
zero(0),
|
|
eight(8),
|
|
thirtyone(31),
|
|
onehundredtwenty(120)
|
|
}
|
|
|
|
TESTMechType::= OBJECT IDENTIFIER
|
|
TESTMechTypeList ::= SEQUENCE OF TESTMechType
|
|
|
|
|
|
-- IOS stuff
|
|
_EXTENSION ::= CLASS {
|
|
&id OBJECT IDENTIFIER UNIQUE,
|
|
&ExtnType,
|
|
&Critical BOOLEAN DEFAULT FALSE
|
|
}
|
|
|
|
TESTExtension{_EXTENSION:ExtensionSet} ::= SEQUENCE {
|
|
extnID _EXTENSION.&id({ExtensionSet}),
|
|
critical BOOLEAN
|
|
-- (EXTENSION.&Critical({ExtensionSet}{@extnID}))
|
|
DEFAULT FALSE,
|
|
extnValue OCTET STRING (CONTAINING
|
|
_EXTENSION.&ExtnType({ExtensionSet}{@extnID}))
|
|
}
|
|
|
|
id-test-default OBJECT IDENTIFIER ::= { 1 2 3 4 }
|
|
testext-TESTDefault _EXTENSION ::= {
|
|
&id id-test-default,
|
|
&Critical FALSE,
|
|
&ExtnType TESTDefault
|
|
}
|
|
|
|
-- And Here's an object set for the EXTENSION CLASS collecting a bunch of
|
|
-- related extensions (here they are the extensions that certificates can
|
|
-- carry in their extensions member):
|
|
TestExtensions _EXTENSION ::= { testext-TESTDefault }
|
|
|
|
TESTExtension ::= TESTExtension { TestExtensions }
|
|
|
|
TESTExtensible ::= SEQUENCE {
|
|
version INTEGER,
|
|
extensions SEQUENCE OF TESTExtension
|
|
}
|
|
|
|
TESTDecorated ::= SEQUENCE {
|
|
version TESTuint32
|
|
-- gets decorated with varius fields (see test.opt)
|
|
}
|
|
|
|
TESTNotDecorated ::= SEQUENCE {
|
|
version TESTuint32
|
|
-- should have the same encoding as TESTDecorated
|
|
}
|
|
|
|
TESTDecoratedChoice ::= CHOICE {
|
|
version TESTuint32
|
|
-- gets decorated with varius fields (see test.opt)
|
|
}
|
|
|
|
TESTNotDecoratedChoice ::= CHOICE {
|
|
version TESTuint32
|
|
-- should have the same encoding as TESTDecoratedChoice
|
|
}
|
|
|
|
END
|