aboutsummaryrefslogtreecommitdiffstats
path: root/asn1/cmip/CMIP.asn
blob: 95d7fb16b13576511ca769ad5531d820eeb3ab83 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
-- some of the definitions use implicit tags  so be careful when adding 
-- new structures.
-- Module CMIP-A-ASSOCIATE-Information (X.711:10/1997)
CMIP-A-ASSOCIATE-Information {joint-iso-itu-t ms(9) cmip(1) modules(0)
  aAssociateUserInfo(1)} DEFINITIONS ::=
BEGIN

IMPORTS
  DistinguishedName, RDNSequence
    FROM InformationFramework;


ObjectClass ::= CHOICE {
  ocglobalForm  [0] IMPLICIT OBJECT IDENTIFIER,
  oclocalForm   [1] IMPLICIT INTEGER
}

ObjectInstance ::= CHOICE {
  distinguishedName       [2] IMPLICIT DistinguishedName,
  nonSpecificForm         [3] IMPLICIT OCTET STRING,
  localDistinguishedName  [4] IMPLICIT RDNSequence
}

BaseManagedObjectId ::= SEQUENCE {
  baseManagedObjectClass     ObjectClass,
  baseManagedObjectInstance  ObjectInstance
}

AttributeId ::= CHOICE {
  globalForm    [0] IMPLICIT OBJECT IDENTIFIER,
  localForm     [1] IMPLICIT INTEGER
}

Attribute ::= SEQUENCE {
  id         AttributeId,
  value      ANY
}

-- This Recommendation | International Standard does not allocate any values for localForm.
-- Where this alternative is used, the permissible values for the integers and their meanings shall be defined
-- as part of the application context in which they are used
FilterItem ::= CHOICE {
  equality                [0] IMPLICIT Attribute,
  substrings
    [1] IMPLICIT SEQUENCE OF
                   CHOICE {initialString  [0] IMPLICIT Attribute,
                           anyString      [1] IMPLICIT Attribute,
                           finalString    [2] IMPLICIT Attribute},
  greaterOrEqual          [2] IMPLICIT Attribute, -- asserted value ? attribute value
  lessOrEqual             [3] IMPLICIT Attribute, -- asserted value <= attribute value
  present                 [4]  AttributeId,
  subsetOf                [5] IMPLICIT Attribute, -- asserted value is a subset of attribute value
  supersetOf              [6] IMPLICIT Attribute, -- asserted value is a superset of attribute value
  nonNullSetIntersection  [7] IMPLICIT Attribute
}

CMISFilter ::= CHOICE {
  item  [8]  FilterItem,
  and   [9] IMPLICIT SET OF CMISFilter,
  or    [10] IMPLICIT SET OF CMISFilter,
  not   [11]  CMISFilter
}

Scope ::= CHOICE {
  namedNumbers      INTEGER {baseObject(0), firstLevelOnly(1), wholeSubtree(2)},
  individualLevels  [1] IMPLICIT INTEGER, -- POSITIVE integer indicates the level to be selected
  baseToNthLevel    [2] IMPLICIT INTEGER
} -- POSITIVE integer N indicates that the range of levels

CMISSync ::= ENUMERATED {bestEffort(0), atomic(1)}

-- Supporting type definitions
--XXX Dont support EXTERNAL yet
--AccessControl ::= EXTERNAL
AccessControl ::= OCTET STRING


GetArgument ::= SEQUENCE {
--  COMPONENTS OF BaseManagedObjectId,  manually expanded
  baseManagedObjectClass     ObjectClass,
  baseManagedObjectInstance  ObjectInstance,
  accessControl    [5]  AccessControl OPTIONAL,
  synchronization  [6] IMPLICIT CMISSync OPTIONAL,
  scope            [7]  Scope OPTIONAL,
  filter           CMISFilter OPTIONAL,
  attributeIdList  [12] IMPLICIT SET OF AttributeId OPTIONAL,
  ...
}

GetResult ::= SEQUENCE {
  managedObjectClass     ObjectClass OPTIONAL,
  managedObjectInstance  ObjectInstance OPTIONAL,
  currentTime            [5] IMPLICIT GeneralizedTime OPTIONAL,
  attributeList          [6] IMPLICIT SET OF Attribute OPTIONAL,
  ...
}

Argument ::= ANY

ReturnResultBody ::= SEQUENCE {
  opcode      Opcode,
  argument    Argument
}

InvokeID ::= INTEGER

Opcode ::= INTEGER { m-EventReport(0), m-EventReport-Confirmed(1), m-Linked-Reply(2), m-Get(3), m-Set(4), m-Set-Confirmed(5), m-Action(6), m-Action-Confirmed(7), m-Create(8), m-Delete(9), m-CancelGet(10) }

InvokeLinkedId ::= CHOICE {
  present [0] IMPLICIT InvokeId,
  absent  [1] IMPLICIT NULL
}

InvokeId ::= CHOICE {
  present InvokeID,
  absent  NULL
}

Invoke ::= SEQUENCE {
  invokeId    InvokeId,
  linkedId    InvokeLinkedId OPTIONAL,
  opcode      Opcode,
  argument    Argument OPTIONAL
}

ReturnResult ::= SEQUENCE {
  invokeId    InvokeId,
  rRBody      ReturnResultBody OPTIONAL
}

ReturnError ::= SEQUENCE {
  invokeId    InvokeId
--XXX need to fill in missing fields here
}


GeneralProblem ::= INTEGER {
  unrecognizedPDU(0), mistypedPDU(1), badlyStructuredPDU(2)
}

InvokeProblem ::= INTEGER {
  duplicateInvocation(0), unrecognizedOperation(1), mistypedArgument(2),
  resourceLimitation(3), releaseInProgress(4), unrecognizedLinkedId(5),
  linkedResponseUnexpected(6), unexpectedLinkedOperation(7)
}

ReturnResultProblem ::= INTEGER {
  unrecognizedInvocation(0), resultResponseUnexpected(1), mistypedResult(2)
}

ReturnErrorProblem ::= INTEGER {
  unrecognizedInvocation(0), errorResponseUnexpected(1), unrecognizedError(2),
  unexpectedError(3), mistypedParameter(4)
}

RejectProblem ::= INTEGER {
  general-unrecognizedPDU(0), general-mistypedPDU(1),
  general-badlyStructuredPDU(2), invoke-duplicateInvocation(10),
  invoke-unrecognizedOperation(11), invoke-mistypedArgument(12),
  invoke-resourceLimitation(13), invoke-releaseInProgress(14),
  invoke-unrecognizedLinkedId(15), invoke-linkedResponseUnexpected(16),
  invoke-unexpectedLinkedOperation(17),
  returnResult-unrecognizedInvocation(20),
  returnResult-resultResponseUnexpected(21), returnResult-mistypedResult(22),
  returnError-unrecognizedInvocation(30),
  returnError-errorResponseUnexpected(31), returnError-unrecognizedError(32),
  returnError-unexpectedError(33), returnError-mistypedParameter(34)
}

RejectProb ::= CHOICE {
  generalProblem      [0] IMPLICIT GeneralProblem,
  invokeProblem       [1] IMPLICIT InvokeProblem,
  returnResultProblem [2] IMPLICIT ReturnResultProblem,
  returnErrorProblem  [3] IMPLICIT ReturnErrorProblem
}
  
Reject ::= SEQUENCE {
  invokeId      InvokeId,
  rejectProblem RejectProb
}

ROS ::= CHOICE {
  invoke       [1] IMPLICIT Invoke,
  returnResult [2] IMPLICIT ReturnResult,
  returnError  [3] IMPLICIT ReturnError,
  reject       [4] IMPLICIT Reject
}






-- CMIP-A-ABORT
--      Information carried in user-information parameter of A-ABORT
CMIPAbortInfo ::= SEQUENCE {
  abortSource  [0] IMPLICIT CMIPAbortSource
--XXX Dont know how to handle EXTERNAL yet
--XXX  userInfo     [1]  EXTERNAL OPTIONAL
}

CMIPAbortSource ::= ENUMERATED {cmiseServiceUser(0), cmiseServiceProvider(1)}




-- CMIP-A-ASSOCIATE
FunctionalUnits ::= BIT STRING {
  multipleObjectSelection(0), filter(1), multipleReply(2), extendedService(3),
  cancelGet(4)}

--	Functional unit i is supported if and only if bit i is one
--	Information carried in user-information parameter of A-ASSOCIATE
CMIPUserInfo ::= SEQUENCE {
  protocolVersion  [0] IMPLICIT ProtocolVersion OPTIONAL,
  functionalUnits  [1] IMPLICIT FunctionalUnits OPTIONAL
--XXX Dont know how to handle EXTERNAL yet
--XXX  accessControl    [2]  EXTERNAL OPTIONAL,
--XXX  userInfo         [3]  EXTERNAL OPTIONAL
}

ProtocolVersion ::= BIT STRING {version1(0), version2(1)}

END

-- Generated by Asnp, the ASN.1 pretty-printer of France Telecom R&D