← Back to branch summary

~ubuntu-branches/ubuntu/trusty/erlang/trusty

« back to all changes in this revision

Viewing changes to lib/asn1/test/asn1_SUITE_data/x420/MSAbstractService.asn

  • Committer: Bazaar Package Importer
  • Author(s): Clint Byrum
  • Date: 2011-05-05 15:48:43 UTC
  • mfrom: (3.5.13 sid)
  • Revision ID: james.westby@ubuntu.com-20110505154843-0om6ekzg6m7ugj27
Tags: 1:14.b.2-dfsg-3ubuntu1
* Merge from debian unstable.  Remaining changes:
  - Drop libwxgtk2.8-dev build dependency. Wx isn't in main, and not
    supposed to.
  - Drop erlang-wx binary.
  - Drop erlang-wx dependency from -megaco, -common-test, and -reltool, they
    do not really need wx. Also drop it from -debugger; the GUI needs wx,
    but it apparently has CLI bits as well, and is also needed by -megaco,
    so let's keep the package for now.
  - debian/patches/series: Do what I meant, and enable build-options.patch
    instead.
* Additional changes:
  - Drop erlang-wx from -et
* Dropped Changes:
  - patches/pcre-crash.patch: CVE-2008-2371: outer level option with
    alternatives caused crash. (Applied Upstream)
  - fix for ssl certificate verification in newSSL: 
    ssl_cacertfile_fix.patch (Applied Upstream)
  - debian/patches/series: Enable native.patch again, to get stripped beam
    files and reduce the package size again. (build-options is what
    actually accomplished this)
  - Remove build-options.patch on advice from upstream and because it caused
    odd build failures.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/asn1/test/asn1_SUITE_data/x420/MSAbstractService.asn
 
1
-- Module MSAbstractService (X.413:06/1999)
 
2
MSAbstractService {joint-iso-itu-t mhs(6) ms(4) modules(0) abstract-service(1)
 
3
  version-1999(1)} DEFINITIONS ::=
 
4
BEGIN
 
5
 
 
6
-- Prologue
 
7
-- Exports everything
 
8
IMPORTS
 
9
  -- MTS information object classes
 
10
  operationObject1, ABSTRACT-ERROR, ABSTRACT-OPERATION, EXTENSION, MHS-OBJECT,
 
11
    PORT,
 
12
    -- MTS objects and ports
 
13
    administration, delivery, mts-user,
 
14
    submission,
 
15
    -- MTS abstract-operations and abstract-errors
 
16
    cancel-deferred-delivery, element-of-service-not-subscribed,
 
17
    inconsistent-request, new-credentials-unacceptable,
 
18
    old-credentials-incorrectly-specified, originator-invalid,
 
19
    recipient-improperly-specified, remote-bind-error, security-error,
 
20
    submission-control, submission-control-violated,
 
21
    unsupported-critical-function,
 
22
    -- MTS abstract-service data-types
 
23
    CertificateSelectors, Credentials, InitiatorCredentials,
 
24
    MessageSubmissionArgument, MessageSubmissionResult, MessageToken,
 
25
    ORAddressAndOrDirectoryName, ProbeSubmissionArgument,
 
26
    ProbeSubmissionResult, ResponderCredentials, SecurityContext, SecurityLabel
 
27
    FROM MTSAbstractService {joint-iso-itu-t mhs(6) mts(3) modules(0)
 
28
      mts-abstract-service(1) version-1999(1)}
 
29
  -- MTS abstract-service 1988 ports
 
30
  administration-88
 
31
    --==
 
32
    FROM MTSAbstractService88 {joint-iso-itu-t mhs(6) mts(3) modules(0)
 
33
      mts-abstract-service(1) version-1988(1988)}
 
34
  -- MTS abstract-service upper bounds
 
35
  ub-content-types, ub-encoded-information-types, ub-labels-and-redirections
 
36
    --==
 
37
    FROM MTSUpperBounds {joint-iso-itu-t mhs(6) mts(3) modules(0)
 
38
      upper-bounds(3) version-1999(1)}
 
39
  -- MS X413ATTRIBUTE table
 
40
  AttributeTable
 
41
    --==
 
42
    FROM MSGeneralAttributeTypes {joint-iso-itu-t mhs(6) ms(4) modules(0)
 
43
      general-attribute-types(2) version-1999(1)}
 
44
  -- MS matching rule table
 
45
  MatchingRuleTable
 
46
    --==
 
47
    FROM MSMatchingRules {joint-iso-itu-t mhs(6) ms(4) modules(0)
 
48
      general-matching-rules(5) version-1999(1)}
 
49
  -- MS auto-action-table and auto-action-error table
 
50
  AutoActionTable, AutoActionErrorTable
 
51
    --==
 
52
    FROM MSGeneralAutoActionTypes {joint-iso-itu-t mhs(6) ms(4) modules(0)
 
53
      general-auto-action-types(3) version-1994(0)}
 
54
  -- MS object-identifiers
 
55
  id-cp-ms-connection, id-crt-ms-access-88, id-crt-ms-access-94,
 
56
    id-ext-modify-capability, id-ext-modify-retrieval-status-capability,
 
57
    id-ext-originator-token, id-ext-originator-certificate-selectors-override,
 
58
    id-ext-protected-change-credentials,
 
59
    id-ext-protected-change-credentials-capability, id-ot-ms, id-ot-ms-user,
 
60
    id-pt-retrieval-88, id-pt-retrieval-94, id-pt-ms-submission
 
61
    --==
 
62
    FROM MSObjectIdentifiers {joint-iso-itu-t mhs(6) ms(4) modules(0)
 
63
      object-identifiers(0) version-1999(1)}
 
64
  -- MS Access abstract-operation and error codes
 
65
  err-attribute-error, err-auto-action-request-error, err-ms-extension-error,
 
66
    err-delete-error, err-entry-class-error, err-fetch-restriction-error,
 
67
    err-invalid-parameters-error, err-message-group-error, err-modify-error,
 
68
    err-range-error, err-security-error, err-sequence-number-error,
 
69
    err-service-error, err-register-ms-error, op-alert, op-delete, op-fetch,
 
70
    op-list, op-modify, op-ms-message-submission, op-ms-probe-submission,
 
71
    op-register-ms, op-summarize
 
72
    --==
 
73
    FROM MSAccessProtocol {joint-iso-itu-t mhs(6) protocols(0) modules(0)
 
74
      ms-access-protocol(2) version-1999(1)}
 
75
  -- MS abstract-service upper bounds
 
76
  ub-attributes-supported, ub-attribute-values, ub-auto-action-errors,
 
77
    ub-auto-actions, ub-auto-registrations, ub-default-registrations,
 
78
    ub-entry-classes, ub-error-reasons, ub-extensions, ub-group-depth,
 
79
    ub-group-descriptor-length, ub-group-part-length, ub-matching-rules,
 
80
    ub-message-groups, ub-messages, ub-modifications, ub-per-entry,
 
81
    ub-per-auto-action, ub-service-information-length, ub-summaries,
 
82
    ub-supplementary-info-length, ub-ua-registration-identifier-length,
 
83
    ub-ua-registrations, ub-restrictions
 
84
    --==
 
85
    FROM MSUpperBounds {joint-iso-itu-t mhs(6) ms(4) modules(0) upper-bounds(4)
 
86
      version-1994(0)}
 
87
  -- MATCHING-RULE information object class
 
88
  MATCHING-RULE
 
89
    --==
 
90
    FROM InformationFramework
 
91
      
 
92
  -- Remote Operations
 
93
  CONTRACT, CONNECTION-PACKAGE
 
94
    --==
 
95
    FROM Remote-Operations-Information-Objects {joint-iso-itu-t
 
96
      remote-operations(4) informationObjects(5) version1(0)}
 
97
  emptyUnbind
 
98
    FROM Remote-Operations-Useful-Definitions {joint-iso-itu-t
 
99
      remote-operations(4) useful-definitions(7) version1(0)};
 
100
 
 
101
-- MS Abstract Objects
 
102
ms MHS-OBJECT ::= {
 
103
  IS        {mts-user}
 
104
  RESPONDS  {ms-access-contract-88 | ms-access-contract-94}
 
105
  ID        id-ot-ms
 
106
}
 
107
 
 
108
ms-user MHS-OBJECT ::= {
 
109
  INITIATES  {ms-access-contract-88 | ms-access-contract-94}
 
110
  ID         id-ot-ms-user
 
111
}
 
112
 
 
113
-- Contracts
 
114
ms-access-contract-94 CONTRACT ::= {
 
115
  CONNECTION             ms-connect
 
116
  INITIATOR CONSUMER OF  {retrieval | ms-submission | administration}
 
117
  ID                     id-crt-ms-access-94
 
118
}
 
119
 
 
120
ms-access-contract-88 CONTRACT ::= {
 
121
  CONNECTION             ms-connect -- with all 1994 extensions omitted 
 
122
  INITIATOR CONSUMER OF  {retrieval-88 | submission | administration-88}
 
123
  ID                     id-crt-ms-access-88
 
124
}
 
125
 
 
126
-- Connection-package
 
127
ms-connect CONNECTION-PACKAGE ::= {
 
128
  BIND    ms-bind
 
129
  UNBIND  ms-unbind
 
130
  ID      id-cp-ms-connection
 
131
}
 
132
 
 
133
-- MS Ports
 
134
retrieval PORT ::= {
 
135
  OPERATIONS        {operationObject1, ...}
 
136
  CONSUMER INVOKES
 
137
    {summarize | list | fetch | delete | register-MS,
 
138
      ... -- 1994 extension addition --, modify}
 
139
  SUPPLIER INVOKES  {alert}
 
140
  ID                id-pt-retrieval-94
 
141
}
 
142
 
 
143
retrieval-88 PORT ::= {
 
144
  -- With all 1994 extensions to the abstract-operations absent 
 
145
  OPERATIONS        {operationObject1, ...}
 
146
  CONSUMER INVOKES  {summarize | list | fetch | delete | register-MS}
 
147
  SUPPLIER INVOKES  {alert}
 
148
  ID                id-pt-retrieval-88
 
149
}
 
150
 
 
151
ms-submission PORT ::= {
 
152
  OPERATIONS        {operationObject1, ...}
 
153
  CONSUMER INVOKES
 
154
    {ms-message-submission | ms-probe-submission | ms-cancel-deferred-delivery}
 
155
  SUPPLIER INVOKES  {ms-submission-control}
 
156
  ID                id-pt-ms-submission
 
157
}
 
158
 
 
159
-- X413ATTRIBUTE information object class
 
160
X413ATTRIBUTE ::= CLASS {
 
161
  &id               AttributeType UNIQUE,
 
162
  &Type             ,
 
163
  &equalityMatch    MATCHING-RULE OPTIONAL,
 
164
  &substringsMatch  MATCHING-RULE OPTIONAL,
 
165
  &orderingMatch    MATCHING-RULE OPTIONAL,
 
166
  &numeration       ENUMERATED {single-valued(0), multi-valued(1)},
 
167
  -- 1994 extension 
 
168
  &OtherMatches     MATCHING-RULE OPTIONAL
 
169
}
 
170
WITH SYNTAX {
 
171
  WITH ATTRIBUTE-SYNTAX &Type,
 
172
  [EQUALITY MATCHING-RULE &equalityMatch,]
 
173
  [SUBSTRINGS MATCHING-RULE &substringsMatch,]
 
174
  [ORDERING MATCHING-RULE &orderingMatch,]
 
175
  [OTHER MATCHING-RULES &OtherMatches,]
 
176
  NUMERATION &numeration,
 
177
  ID &id
 
178
}
 
179
 
 
180
Attribute ::= SEQUENCE {
 
181
  attribute-type    X413ATTRIBUTE.&id({AttributeTable}),
 
182
  attribute-values
 
183
    SEQUENCE SIZE (1..ub-attribute-values) OF
 
184
      X413ATTRIBUTE.&Type({AttributeTable}{@attribute-type})
 
185
}
 
186
 
 
187
AttributeType ::= OBJECT IDENTIFIER
 
188
 
 
189
-- AUTO-ACTION information object class
 
190
AUTO-ACTION ::= CLASS {
 
191
  &id                     AutoActionType UNIQUE,
 
192
  &RegistrationParameter  OPTIONAL,
 
193
  &Errors                 AUTO-ACTION-ERROR OPTIONAL
 
194
}
 
195
WITH SYNTAX {
 
196
  [REGISTRATION PARAMETER IS &RegistrationParameter]
 
197
  [ERRORS &Errors]
 
198
  IDENTIFIED BY &id
 
199
}
 
200
 
 
201
AutoActionType ::= OBJECT IDENTIFIER
 
202
 
 
203
AutoActionRegistration ::= SEQUENCE {
 
204
  auto-action-type         AUTO-ACTION.&id({AutoActionTable}),
 
205
  registration-identifier  [0]  INTEGER(1..ub-per-auto-action) DEFAULT 1,
 
206
  registration-parameter
 
207
    [1]  AUTO-ACTION.&RegistrationParameter
 
208
           ({AutoActionTable}{@auto-action-type}) OPTIONAL
 
209
}
 
210
 
 
211
-- AUTO-ACTION-ERROR information object class
 
212
AUTO-ACTION-ERROR ::=
 
213
  ABSTRACT-ERROR
 
214
 
 
215
AutoActionError ::= SET {
 
216
  error-code       [0]  AUTO-ACTION-ERROR.&errorCode({AutoActionErrorTable}),
 
217
  error-parameter
 
218
    [1]  AUTO-ACTION-ERROR.&ParameterType({AutoActionErrorTable}{@error-code})
 
219
      OPTIONAL
 
220
}
 
221
 
 
222
-- MS-EXTENSION information object class
 
223
MS-EXTENSION ::= TYPE-IDENTIFIER
 
224
 
 
225
MSExtensionItem ::= INSTANCE OF MS-EXTENSION
 
226
 
 
227
MSExtensions ::= SEQUENCE SIZE (1..ub-extensions) OF MSExtensionItem
 
228
 
 
229
-- Common data-types related to the information model
 
230
EntryClass ::= INTEGER {
 
231
  delivery(0),
 
232
  -- 1994 extensions 
 
233
  submission(1), draft(2), stored-message(3), delivery-log(4),
 
234
  submission-log(5), message-log(6), auto-action-log(7)}(0..ub-entry-classes)
 
235
 
 
236
EntryType ::= INTEGER {
 
237
  delivered-message(0), delivered-report(1),
 
238
  returned-content(2),
 
239
  -- 1994 extensions 
 
240
  submitted-message(3), submitted-probe(4), draft-message(5),
 
241
  auto-action-event(6)}
 
242
 
 
243
SequenceNumber ::= INTEGER(0..ub-messages)
 
244
 
 
245
RetrievalStatus ::= INTEGER {new(0), listed(1), processed(2)}
 
246
 
 
247
MessageGroupName ::= SEQUENCE SIZE (1..ub-group-depth) OF GroupNamePart
 
248
 
 
249
GroupNamePart ::= GeneralString(SIZE (1..ub-group-part-length))
 
250
 
 
251
-- MS-bind abstract-operation
 
252
ms-bind ABSTRACT-OPERATION ::= {
 
253
  ARGUMENT  MSBindArgument
 
254
  RESULT    MSBindResult
 
255
  ERRORS    {ms-bind-error}
 
256
}
 
257
 
 
258
MSBindArgument ::= SET {
 
259
  initiator-name              ORAddressAndOrDirectoryName,
 
260
  initiator-credentials       [2]  InitiatorCredentials,
 
261
  security-context            [3] IMPLICIT SecurityContext OPTIONAL,
 
262
  fetch-restrictions          [4]  Restrictions OPTIONAL -- default is none--,
 
263
  ms-configuration-request    [5]  BOOLEAN DEFAULT FALSE,
 
264
  -- 1994 extensions 
 
265
  ua-registration-identifier  [6]  RegistrationIdentifier OPTIONAL,
 
266
  bind-extensions             [7]  MSExtensions OPTIONAL
 
267
}
 
268
 
 
269
Restrictions ::= SET {
 
270
  allowed-content-types
 
271
    [0]  SET SIZE (1..ub-content-types) OF OBJECT IDENTIFIER OPTIONAL--default is no restriction--,
 
272
  allowed-EITs              [1]  MS-EITs OPTIONAL --default is no restriction--,
 
273
  maximum-attribute-length  [2]  INTEGER OPTIONAL --default is no restriction--
 
274
}
 
275
 
 
276
MS-EITs ::= SET SIZE (1..ub-encoded-information-types) OF MS-EIT
 
277
 
 
278
MS-EIT ::= OBJECT IDENTIFIER
 
279
 
 
280
RegistrationIdentifier ::=
 
281
  PrintableString(SIZE (1..ub-ua-registration-identifier-length))
 
282
 
 
283
MSBindResult ::= SET {
 
284
  responder-credentials         [2]  ResponderCredentials,
 
285
  available-auto-actions
 
286
    [3]  SET SIZE (1..ub-auto-actions) OF AUTO-ACTION.&id({AutoActionTable})
 
287
      OPTIONAL,
 
288
  available-attribute-types
 
289
    [4]  SET SIZE (1..ub-attributes-supported) OF
 
290
           X413ATTRIBUTE.&id({AttributeTable}) OPTIONAL,
 
291
  alert-indication              [5]  BOOLEAN DEFAULT FALSE,
 
292
  content-types-supported
 
293
    [6]  SET SIZE (1..ub-content-types) OF OBJECT IDENTIFIER OPTIONAL,
 
294
  -- 1994 extensions 
 
295
  entry-classes-supported
 
296
    [7]  SET SIZE (1..ub-entry-classes) OF EntryClass OPTIONAL,
 
297
  matching-rules-supported
 
298
    [8]  SET SIZE (1..ub-matching-rules) OF OBJECT IDENTIFIER OPTIONAL,
 
299
  bind-result-extensions        [9]  MSExtensions OPTIONAL,
 
300
  message-group-depth           [10]  INTEGER(1..ub-group-depth) OPTIONAL,
 
301
  auto-action-error-indication  [11]  AutoActionErrorIndication OPTIONAL,
 
302
  unsupported-extensions
 
303
    [12]  SET SIZE (1..ub-extensions) OF OBJECT IDENTIFIER OPTIONAL,
 
304
  ua-registration-id-unknown    [13]  BOOLEAN DEFAULT FALSE,
 
305
  service-information
 
306
    [14]  GeneralString(SIZE (1..ub-service-information-length)) OPTIONAL
 
307
}
 
308
 
 
309
modify-capability MS-EXTENSION ::= {
 
310
  NULL
 
311
  IDENTIFIED BY  id-ext-modify-capability
 
312
}
 
313
 
 
314
modify-retrieval-status-capability MS-EXTENSION ::= {
 
315
  NULL
 
316
  IDENTIFIED BY  id-ext-modify-retrieval-status-capability
 
317
}
 
318
 
 
319
protected-change-credentials-capability MS-EXTENSION ::= {
 
320
  ChangeCredentialsAlgorithms
 
321
  IDENTIFIED BY  id-ext-protected-change-credentials-capability
 
322
}
 
323
 
 
324
ChangeCredentialsAlgorithms ::= SET OF OBJECT IDENTIFIER
 
325
 
 
326
AutoActionErrorIndication ::= CHOICE {
 
327
  indication-only        [0]  NULL,
 
328
  auto-action-log-entry  [1]  SequenceNumber
 
329
}
 
330
 
 
331
ms-bind-error ABSTRACT-ERROR ::= {
 
332
  PARAMETER
 
333
    CHOICE {unqualified-error  BindProblem,
 
334
            -- 1994 extension 
 
335
            qualified-error
 
336
              SET {bind-problem               [0]  BindProblem,
 
337
                   supplementary-information
 
338
                     [1]  GeneralString(SIZE (1..ub-supplementary-info-length))
 
339
                       OPTIONAL,
 
340
                   bind-extension-errors
 
341
                     [2]  SET SIZE (1..ub-extensions) OF OBJECT IDENTIFIER
 
342
                       OPTIONAL}}
 
343
}
 
344
 
 
345
BindProblem ::= ENUMERATED {
 
346
  authentication-error(0), unacceptable-security-context(1),
 
347
  unable-to-establish-association(2), ... -- 1994 extension addition --, 
 
348
  bind-extension-problem(3), inadequate-association-confidentiality(4)
 
349
}
 
350
 
 
351
-- MS Unbind abstract-operation
 
352
ms-unbind ABSTRACT-OPERATION ::= emptyUnbind
 
353
 
 
354
-- Common data-types
 
355
Range ::= CHOICE {
 
356
  sequence-number-range  [0]  NumberRange,
 
357
  creation-time-range    [1]  TimeRange
 
358
}
 
359
 
 
360
NumberRange ::= SEQUENCE {
 
361
  from  [0]  SequenceNumber OPTIONAL -- omitted means no lower bound--,
 
362
  to    [1]  SequenceNumber OPTIONAL -- omitted means no upper bound--
 
363
}
 
364
 
 
365
TimeRange ::= SEQUENCE {
 
366
  from  [0]  CreationTime OPTIONAL -- omitted means no lower bound--,
 
367
  to    [1]  CreationTime OPTIONAL -- omitted means no upper bound--
 
368
}
 
369
 
 
370
CreationTime ::= UTCTime
 
371
 
 
372
Filter ::= CHOICE {
 
373
  item  [0]  FilterItem,
 
374
  and   [1]  SET OF Filter,
 
375
  or    [2]  SET OF Filter,
 
376
  not   [3]  Filter
 
377
}
 
378
 
 
379
FilterItem ::= CHOICE {
 
380
  equality           [0]  AttributeValueAssertion,
 
381
  substrings
 
382
    [1]  SEQUENCE {type     X413ATTRIBUTE.&id({AttributeTable}),
 
383
                   strings
 
384
                     SEQUENCE OF
 
385
                       CHOICE {initial
 
386
                                 [0]  X413ATTRIBUTE.&Type
 
387
                                        ({AttributeTable}{@substrings.type}),
 
388
                               any
 
389
                                 [1]  X413ATTRIBUTE.&Type
 
390
                                        ({AttributeTable}{@substrings.type}),
 
391
                               final
 
392
                                 [2]  X413ATTRIBUTE.&Type
 
393
                                        ({AttributeTable}{@substrings.type})
 
394
                       }},
 
395
  greater-or-equal   [2]  AttributeValueAssertion,
 
396
  less-or-equal      [3]  AttributeValueAssertion,
 
397
  present            [4]  X413ATTRIBUTE.&id({AttributeTable}),
 
398
  approximate-match  [5]  AttributeValueAssertion,
 
399
  -- 1994 extension 
 
400
  other-match        [6]  MatchingRuleAssertion
 
401
}
 
402
 
 
403
MatchingRuleAssertion ::= SEQUENCE {
 
404
  matching-rule   [0]  MATCHING-RULE.&id({MatchingRuleTable}),
 
405
  attribute-type  [1]  X413ATTRIBUTE.&id,
 
406
  match-value
 
407
    [2]  MATCHING-RULE.&AssertionType({MatchingRuleTable}{@matching-rule})
 
408
}
 
409
 
 
410
AttributeValueAssertion ::= SEQUENCE {
 
411
  attribute-type   X413ATTRIBUTE.&id({AttributeTable}),
 
412
  attribute-value  X413ATTRIBUTE.&Type({AttributeTable}{@attribute-type})
 
413
}
 
414
 
 
415
Selector ::= SET {
 
416
  child-entries  [0]  BOOLEAN DEFAULT FALSE,
 
417
  range          [1]  Range OPTIONAL -- default is unbounded --,
 
418
  filter
 
419
    [2]  Filter
 
420
      OPTIONAL -- default is all entries within the specified range --,
 
421
  limit          [3]  INTEGER(1..ub-messages) OPTIONAL,
 
422
  override       [4]  OverrideRestrictions OPTIONAL -- by default, --
 
423
  -- any fetch-restrictions in force apply
 
424
}
 
425
 
 
426
OverrideRestrictions ::= BIT STRING {
 
427
  override-content-types-restriction(0), override-EITs-restriction(1),
 
428
  override-attribute-length-restriction(2)}(SIZE (1..ub-restrictions))
 
429
 
 
430
EntryInformationSelection ::= SET SIZE (0..ub-per-entry) OF AttributeSelection
 
431
 
 
432
AttributeSelection ::= SET {
 
433
  type   X413ATTRIBUTE.&id({AttributeTable}),
 
434
  from
 
435
    [0]  INTEGER(1..ub-attribute-values)
 
436
      OPTIONAL --used if type is multi valued--,
 
437
  count
 
438
    [1]  INTEGER(0..ub-attribute-values)
 
439
      OPTIONAL --used if type is multi valued--
 
440
}
 
441
 
 
442
EntryInformation ::= SEQUENCE {
 
443
  sequence-number       SequenceNumber,
 
444
  attributes            SET SIZE (1..ub-per-entry) OF Attribute OPTIONAL,
 
445
  -- 1994 extension 
 
446
  value-count-exceeded
 
447
    [0]  SET SIZE (1..ub-per-entry) OF AttributeValueCount OPTIONAL
 
448
}
 
449
 
 
450
AttributeValueCount ::= SEQUENCE {
 
451
  type   [0]  X413ATTRIBUTE.&id({AttributeTable}),
 
452
  total  [1]  INTEGER
 
453
}
 
454
 
 
455
MSSubmissionOptions ::= SET {
 
456
  object-entry-class
 
457
    [0]  EntryClass(submission | submission-log | draft) OPTIONAL,
 
458
  disable-auto-modify       [1]  BOOLEAN DEFAULT FALSE,
 
459
  add-message-group-names
 
460
    [2]  SET SIZE (1..ub-message-groups) OF MessageGroupName OPTIONAL,
 
461
  ms-submission-extensions  [3]  MSExtensions OPTIONAL
 
462
}
 
463
 
 
464
originator-token MS-EXTENSION ::= {
 
465
  OriginatorToken
 
466
  IDENTIFIED BY  id-ext-originator-token
 
467
}
 
468
 
 
469
OriginatorToken ::=
 
470
  MessageToken
 
471
    (CONSTRAINED BY {
 
472
       
 
473
       -- Must contain an asymmetric-token with an encrypted-data component --})
 
474
 
 
475
originator-certificate-selectors-override MS-EXTENSION ::= {
 
476
  CertificateSelectors
 
477
    (WITH COMPONENTS {
 
478
       ...,
 
479
       message-origin-authentication  ABSENT
 
480
     })
 
481
  IDENTIFIED BY  id-ext-originator-certificate-selectors-override
 
482
}
 
483
 
 
484
CommonSubmissionResults ::= SET {
 
485
  created-entry                    [0]  SequenceNumber OPTIONAL,
 
486
  auto-action-error-indication     [1]  AutoActionErrorIndication OPTIONAL,
 
487
  ms-submission-result-extensions  [2]  MSExtensions OPTIONAL
 
488
}
 
489
 
 
490
-- Retrieval Port abstract-operations
 
491
summarize ABSTRACT-OPERATION ::= {
 
492
  ARGUMENT  SummarizeArgument
 
493
  RESULT    SummarizeResult
 
494
  ERRORS
 
495
    {attribute-error | invalid-parameters-error | range-error | security-error
 
496
      | service-error, ... -- 1994 extension additions --, entry-class-error |
 
497
      ms-extension-error}
 
498
  LINKED    {operationObject1, ...}
 
499
  CODE      op-summarize
 
500
}
 
501
 
 
502
SummarizeArgument ::= SET {
 
503
  entry-class           [0]  EntryClass DEFAULT delivery,
 
504
  selector              [1]  Selector,
 
505
  summary-requests
 
506
    [2]  SEQUENCE SIZE (1..ub-summaries) OF X413ATTRIBUTE.&id({AttributeTable})
 
507
      OPTIONAL -- absent if no summaries are requested--,
 
508
  -- 1994 extension 
 
509
  summarize-extensions  [3]  MSExtensions OPTIONAL
 
510
}
 
511
 
 
512
SummarizeResult ::= SET {
 
513
  next                         [0]  SequenceNumber OPTIONAL,
 
514
  count
 
515
    [1]  INTEGER(0..ub-messages)-- of the entries selected-- ,
 
516
  span                         [2]  Span OPTIONAL -- of the entries selected,---- omitted if count is zero --,
 
517
  summaries
 
518
    [3]  SEQUENCE SIZE (1..ub-summaries) OF Summary OPTIONAL,
 
519
  -- 1994 extension 
 
520
  summarize-result-extensions  [4]  MSExtensions OPTIONAL
 
521
}
 
522
 
 
523
Span ::= SEQUENCE {lowest   [0]  SequenceNumber,
 
524
                   highest  [1]  SequenceNumber
 
525
}
 
526
 
 
527
Summary ::= SET {
 
528
  absent
 
529
    [0]  INTEGER(1..ub-messages)
 
530
      OPTIONAL --count of entries where X413ATTRIBUTE is absent--,
 
531
  present
 
532
    [1]  SET SIZE (1..ub-attribute-values)
 
533
           OF--one for each X413ATTRIBUTE value present--
 
534
           SEQUENCE {type   X413ATTRIBUTE.&id({AttributeTable}),
 
535
                     value  X413ATTRIBUTE.&Type({AttributeTable}{@.type}),
 
536
                     count  INTEGER(1..ub-messages)} OPTIONAL
 
537
}
 
538
 
 
539
-- 
 
540
list ABSTRACT-OPERATION ::= {
 
541
  ARGUMENT  ListArgument
 
542
  RESULT    ListResult
 
543
  ERRORS
 
544
    {attribute-error | invalid-parameters-error | range-error | security-error
 
545
      | service-error, ... -- 1994 extension additions --, entry-class-error |
 
546
      ms-extension-error}
 
547
  LINKED    {operationObject1, ...}
 
548
  CODE      op-list
 
549
}
 
550
 
 
551
ListArgument ::= SET {
 
552
  entry-class           [0]  EntryClass DEFAULT delivery,
 
553
  selector              [1]  Selector,
 
554
  requested-attributes  [3]  EntryInformationSelection OPTIONAL,
 
555
  -- 1994 extension 
 
556
  list-extensions       [4]  MSExtensions OPTIONAL
 
557
}
 
558
 
 
559
ListResult ::= SET {
 
560
  next                    [0]  SequenceNumber OPTIONAL,
 
561
  requested
 
562
    [1]  SEQUENCE SIZE (1..ub-messages) OF EntryInformation OPTIONAL--omitted if none found--,
 
563
  -- 1994 extension 
 
564
  list-result-extensions  [2]  MSExtensions OPTIONAL
 
565
}
 
566
 
 
567
-- 
 
568
fetch ABSTRACT-OPERATION ::= {
 
569
  ARGUMENT  FetchArgument
 
570
  RESULT    FetchResult
 
571
  ERRORS
 
572
    {attribute-error | fetch-restriction-error | invalid-parameters-error |
 
573
      range-error | security-error | sequence-number-error | service-error,
 
574
      ... -- 1994 extension additions --, entry-class-error |
 
575
      ms-extension-error}
 
576
  LINKED    {operationObject1, ...}
 
577
  CODE      op-fetch
 
578
}
 
579
 
 
580
FetchArgument ::= SET {
 
581
  entry-class           [0]  EntryClass DEFAULT delivery,
 
582
  item
 
583
    CHOICE {search   [1]  Selector,
 
584
            precise  [2]  SequenceNumber},
 
585
  requested-attributes  [3]  EntryInformationSelection OPTIONAL,
 
586
  -- 1994 extension 
 
587
  fetch-extensions      [4]  MSExtensions OPTIONAL
 
588
}
 
589
 
 
590
FetchResult ::= SET {
 
591
  entry-information
 
592
    [0]  EntryInformation OPTIONAL --if an entry was selected--,
 
593
  list
 
594
    [1]  SEQUENCE SIZE (1..ub-messages) OF SequenceNumber OPTIONAL,
 
595
  next                     [2]  SequenceNumber OPTIONAL,
 
596
  -- 1994 extension 
 
597
  fetch-result-extensions  [3]  MSExtensions OPTIONAL
 
598
}
 
599
 
 
600
-- 
 
601
delete ABSTRACT-OPERATION ::= {
 
602
  ARGUMENT  DeleteArgument
 
603
  RESULT    DeleteResult
 
604
  ERRORS
 
605
    {delete-error | invalid-parameters-error | range-error | security-error |
 
606
      sequence-number-error | service-error,
 
607
      ... -- 1994 extension additions --, entry-class-error |
 
608
      ms-extension-error}
 
609
  LINKED    {operationObject1, ...}
 
610
  CODE      op-delete
 
611
}
 
612
 
 
613
DeleteArgument ::= SET {
 
614
  entry-class        [0]  EntryClass DEFAULT delivery,
 
615
  items
 
616
    CHOICE {selector          [1]  Selector,
 
617
            sequence-numbers  [2]  SET SIZE (1..ub-messages) OF SequenceNumber
 
618
  },
 
619
  -- 1994 extension
 
620
  delete-extensions  [3]  MSExtensions OPTIONAL
 
621
}
 
622
 
 
623
DeleteResult ::= CHOICE {
 
624
  delete-result-88  NULL,
 
625
  -- 1994 extension 
 
626
  delete-result-94
 
627
    SET {entries-deleted
 
628
           [0]  SEQUENCE SIZE (1..ub-messages) OF SequenceNumber OPTIONAL,
 
629
         delete-result-extensions  [1]  MSExtensions OPTIONAL}
 
630
}
 
631
 
 
632
-- 
 
633
register-MS ABSTRACT-OPERATION ::= {
 
634
  ARGUMENT  Register-MSArgument
 
635
  RESULT    Register-MSResult
 
636
  ERRORS
 
637
    {attribute-error | auto-action-request-error | invalid-parameters-error |
 
638
      security-error | service-error | old-credentials-incorrectly-specified |
 
639
      new-credentials-unacceptable, ... -- 1994 extension additions --,
 
640
      message-group-error | ms-extension-error | register-ms-error}
 
641
  LINKED    {operationObject1, ...}
 
642
  CODE      op-register-ms
 
643
}
 
644
 
 
645
Register-MSArgument ::= SET {
 
646
  auto-action-registrations
 
647
    [0]  SET SIZE (1..ub-auto-registrations) OF AutoActionRegistration OPTIONAL,
 
648
  auto-action-deregistrations
 
649
    [1]  SET SIZE (1..ub-auto-registrations) OF AutoActionDeregistration
 
650
      OPTIONAL,
 
651
  list-attribute-defaults
 
652
    [2]  SET SIZE (0..ub-default-registrations) OF
 
653
           X413ATTRIBUTE.&id({AttributeTable}) OPTIONAL,
 
654
  fetch-attribute-defaults
 
655
    [3]  SET SIZE (0..ub-default-registrations) OF
 
656
           X413ATTRIBUTE.&id({AttributeTable}) OPTIONAL,
 
657
  change-credentials
 
658
    [4]  SEQUENCE {old-credentials
 
659
                     [0]  Credentials(WITH COMPONENTS {
 
660
                                        simple  
 
661
                                      }),
 
662
                   new-credentials
 
663
                     [1]  Credentials(WITH COMPONENTS {
 
664
                                        simple  
 
665
                                      })} OPTIONAL,
 
666
  user-security-labels
 
667
    [5]  SET SIZE (1..ub-labels-and-redirections) OF SecurityLabel OPTIONAL,
 
668
  -- 1994 extensions
 
669
  ua-registrations
 
670
    [6]  SET SIZE (1..ub-ua-registrations) OF UARegistration OPTIONAL,
 
671
  submission-defaults          [7]  MSSubmissionOptions OPTIONAL,
 
672
  message-group-registrations  [8]  MessageGroupRegistrations OPTIONAL,
 
673
  registration-status-request  [9]  RegistrationTypes OPTIONAL,
 
674
  register-ms-extensions       [10]  MSExtensions OPTIONAL
 
675
}
 
676
 
 
677
AutoActionDeregistration ::= SEQUENCE {
 
678
  auto-action-type         AUTO-ACTION.&id({AutoActionTable}),
 
679
  registration-identifier  [0]  INTEGER(1..ub-per-auto-action) DEFAULT 1
 
680
}
 
681
 
 
682
UARegistration ::= SET {
 
683
  ua-registration-identifier   [0]  RegistrationIdentifier,
 
684
  ua-list-attribute-defaults
 
685
    [1]  SET SIZE (0..ub-default-registrations) OF
 
686
           X413ATTRIBUTE.&id({AttributeTable}) OPTIONAL,
 
687
  ua-fetch-attribute-defaults
 
688
    [2]  SET SIZE (0..ub-default-registrations) OF
 
689
           X413ATTRIBUTE.&id({AttributeTable}) OPTIONAL,
 
690
  ua-submission-defaults       [3]  MSSubmissionOptions OPTIONAL,
 
691
  content-specific-defaults    [4]  MSExtensions OPTIONAL
 
692
}
 
693
 
 
694
MessageGroupRegistrations ::=
 
695
  SEQUENCE SIZE (1..ub-default-registrations) OF
 
696
    CHOICE {register-group      [0]  MessageGroupNameAndDescriptor,
 
697
            deregister-group    [1]  MessageGroupName,
 
698
            change-descriptors  [2]  MessageGroupNameAndDescriptor}
 
699
 
 
700
MessageGroupNameAndDescriptor ::= SET {
 
701
  message-group-name        [0]  MessageGroupName,
 
702
  message-group-descriptor
 
703
    [1]  GeneralString(SIZE (1..ub-group-descriptor-length)) OPTIONAL
 
704
}
 
705
 
 
706
RegistrationTypes ::= SET {
 
707
  registrations
 
708
    [0]  BIT STRING {auto-action-registrations(0), list-attribute-defaults(1),
 
709
                     fetch-attribute-defaults(2), ua-registrations(3),
 
710
                     submission-defaults(4), message-group-registrations(5)}
 
711
      OPTIONAL,
 
712
  extended-registrations   [1]  SET OF MS-EXTENSION.&id OPTIONAL,
 
713
  restrict-message-groups  [2]  MessageGroupsRestriction OPTIONAL
 
714
}
 
715
 
 
716
MessageGroupsRestriction ::= SET {
 
717
  parent-group                [0]  MessageGroupName OPTIONAL,
 
718
  immediate-descendants-only  [1]  BOOLEAN DEFAULT TRUE,
 
719
  omit-descriptors            [2]  BOOLEAN DEFAULT TRUE
 
720
}
 
721
 
 
722
protected-change-credentials MS-EXTENSION ::= {
 
723
  ProtectedChangeCredentials
 
724
  IDENTIFIED BY  id-ext-protected-change-credentials
 
725
}
 
726
 
 
727
ProtectedChangeCredentials ::= SEQUENCE {
 
728
  algorithm-identifier  [0] IMPLICIT OBJECT IDENTIFIER,
 
729
  old-credentials
 
730
    InitiatorCredentials(WITH COMPONENTS {
 
731
                           protected  PRESENT
 
732
                         }),
 
733
  password-delta        [2] IMPLICIT BIT STRING
 
734
}
 
735
 
 
736
Register-MSResult ::= CHOICE {
 
737
  no-status-information   NULL,
 
738
  -- 1994 extension 
 
739
  registered-information
 
740
    SET {auto-action-registrations
 
741
           [0]  SET SIZE (1..ub-auto-registrations) OF AutoActionRegistration
 
742
             OPTIONAL,
 
743
         list-attribute-defaults
 
744
           [1]  SET SIZE (1..ub-default-registrations) OF
 
745
                  X413ATTRIBUTE.&id({AttributeTable}) OPTIONAL,
 
746
         fetch-attribute-defaults
 
747
           [2]  SET SIZE (1..ub-default-registrations) OF
 
748
                  X413ATTRIBUTE.&id({AttributeTable}) OPTIONAL,
 
749
         ua-registrations
 
750
           [3]  SET SIZE (1..ub-ua-registrations) OF UARegistration OPTIONAL,
 
751
         submission-defaults            [4]  MSSubmissionOptions OPTIONAL,
 
752
         message-group-registrations
 
753
           [5]  SET SIZE (1..ub-message-groups) OF
 
754
                  MessageGroupNameAndDescriptor OPTIONAL,
 
755
         register-ms-result-extensions  [6]  MSExtensions OPTIONAL}
 
756
}
 
757
 
 
758
-- 
 
759
alert ABSTRACT-OPERATION ::= {
 
760
  ARGUMENT  AlertArgument
 
761
  RESULT    AlertResult
 
762
  ERRORS    {security-error}
 
763
  LINKED    {operationObject1, ...}
 
764
  CODE      op-alert
 
765
}
 
766
 
 
767
AlertArgument ::= SET {
 
768
  alert-registration-identifier  [0]  INTEGER(1..ub-auto-actions),
 
769
  new-entry                      [2]  EntryInformation OPTIONAL
 
770
}
 
771
 
 
772
AlertResult ::= NULL
 
773
 
 
774
-- 
 
775
modify ABSTRACT-OPERATION ::= {
 
776
  ARGUMENT  ModifyArgument
 
777
  RESULT    ModifyResult
 
778
  ERRORS
 
779
    {attribute-error | invalid-parameters-error | security-error |
 
780
      sequence-number-error | service-error | modify-error |
 
781
      message-group-error | entry-class-error | ms-extension-error,
 
782
      ... -- For future extension additions --}
 
783
  LINKED    {operationObject1, ...}
 
784
  CODE      op-modify
 
785
}
 
786
 
 
787
ModifyArgument ::= SET {
 
788
  entry-class        [0]  EntryClass DEFAULT delivery,
 
789
  entries
 
790
    CHOICE {selector          [1]  Selector,
 
791
            specific-entries
 
792
              [2]  SEQUENCE SIZE (1..ub-messages) OF SequenceNumber},
 
793
  modifications
 
794
    [3]  SEQUENCE SIZE (1..ub-modifications) OF EntryModification,
 
795
  modify-extensions  [4]  MSExtensions OPTIONAL
 
796
}
 
797
 
 
798
EntryModification ::= SET {
 
799
  strict        [0]  BOOLEAN DEFAULT FALSE,
 
800
  modification
 
801
    CHOICE {add-attribute     [1]  Attribute,
 
802
            remove-attribute  [2]  X413ATTRIBUTE.&id({AttributeTable}),
 
803
            add-values        [3]  OrderedAttribute,
 
804
            remove-values     [4]  OrderedAttribute}
 
805
}
 
806
 
 
807
OrderedAttribute ::= SEQUENCE {
 
808
  attribute-type    X413ATTRIBUTE.&id({AttributeTable}),
 
809
  attribute-values
 
810
    SEQUENCE SIZE (1..ub-attribute-values) OF
 
811
      SEQUENCE {-- at least one must be specified 
 
812
                value
 
813
                  [0]  X413ATTRIBUTE.&Type({AttributeTable}{@attribute-type})
 
814
                    OPTIONAL,
 
815
                position  [1]  INTEGER(1..ub-attribute-values) OPTIONAL
 
816
      }
 
817
}
 
818
 
 
819
ModifyResult ::= SET {
 
820
  entries-modified
 
821
    [0]  SEQUENCE SIZE (1..ub-messages) OF SequenceNumber OPTIONAL,
 
822
  modify-result-extensions  [1]  MSExtensions OPTIONAL
 
823
}
 
824
 
 
825
-- MS-submission Port abstract-operations
 
826
ms-message-submission ABSTRACT-OPERATION ::= {
 
827
  ARGUMENT  MSMessageSubmissionArgument
 
828
  RESULT    MSMessageSubmissionResult
 
829
  ERRORS
 
830
    {submission-control-violated | element-of-service-not-subscribed |
 
831
      originator-invalid | recipient-improperly-specified |
 
832
      inconsistent-request | security-error | unsupported-critical-function |
 
833
      remote-bind-error, ... -- 1994 extension additions --, ms-extension-error
 
834
      | message-group-error | entry-class-error | service-error}
 
835
  LINKED    {operationObject1, ...}
 
836
  CODE      op-ms-message-submission
 
837
}
 
838
 
 
839
MSMessageSubmissionArgument ::= SEQUENCE {
 
840
  COMPONENTS OF
 
841
    MessageSubmissionArgument -- This imported type has IMPLICIT tags --,
 
842
  -- 1994 extension 
 
843
  submission-options  [4]  MSSubmissionOptions OPTIONAL
 
844
}
 
845
 
 
846
forwarding-request EXTENSION ::= {
 
847
  SequenceNumber,
 
848
  IDENTIFIED BY  standard-extension:36
 
849
}
 
850
 
 
851
MSMessageSubmissionResult ::= CHOICE {
 
852
  mts-result
 
853
    SET {COMPONENTS OF
 
854
           MessageSubmissionResult-- This imported type has IMPLICIT tags -- ,
 
855
         -- 1994 extension 
 
856
         ms-message-result  [4]  CommonSubmissionResults OPTIONAL},
 
857
  -- 1994 extension 
 
858
  store-draft-result  [4]  CommonSubmissionResults
 
859
}
 
860
 
 
861
-- 
 
862
ms-probe-submission ABSTRACT-OPERATION ::= {
 
863
  ARGUMENT  MSProbeSubmissionArgument
 
864
  RESULT    MSProbeSubmissionResult
 
865
  ERRORS
 
866
    {submission-control-violated | element-of-service-not-subscribed |
 
867
      originator-invalid | recipient-improperly-specified |
 
868
      inconsistent-request | security-error | unsupported-critical-function |
 
869
      remote-bind-error, ... -- 1994 extension additions --, ms-extension-error
 
870
      | message-group-error | entry-class-error | service-error}
 
871
  LINKED    {operationObject1, ...}
 
872
  CODE      op-ms-probe-submission
 
873
}
 
874
 
 
875
MSProbeSubmissionArgument ::= SET {
 
876
  COMPONENTS OF
 
877
    ProbeSubmissionArgument -- This imported type has IMPLICIT tags --,
 
878
  -- 1994 extension 
 
879
  submission-options  [4]  MSSubmissionOptions OPTIONAL
 
880
}
 
881
 
 
882
MSProbeSubmissionResult ::= SET {
 
883
  COMPONENTS OF
 
884
    ProbeSubmissionResult -- This imported type has IMPLICIT tags --,
 
885
  -- 1994 extension 
 
886
  ms-probe-result  [4]  CommonSubmissionResults OPTIONAL
 
887
}
 
888
 
 
889
ms-cancel-deferred-delivery ABSTRACT-OPERATION ::= cancel-deferred-delivery
 
890
 
 
891
ms-submission-control ABSTRACT-OPERATION ::= submission-control
 
892
 
 
893
-- Abstract-errors
 
894
attribute-error ABSTRACT-ERROR ::= {
 
895
  PARAMETER
 
896
    SET {problems
 
897
           [0]  SET SIZE (1..ub-per-entry) OF
 
898
                  SET {problem  [0]  AttributeProblem,
 
899
                       type     [1]  X413ATTRIBUTE.&id({AttributeTable}),
 
900
                       value
 
901
                         [2]  X413ATTRIBUTE.&Type({AttributeTable}{@.type})
 
902
                           OPTIONAL}}
 
903
  CODE       err-attribute-error
 
904
}
 
905
 
 
906
AttributeProblem ::= INTEGER {
 
907
  invalid-attribute-value(0), unavailable-attribute-type(1),
 
908
  inappropriate-matching(2), attribute-type-not-subscribed(3),
 
909
  inappropriate-for-operation(4),
 
910
  -- 1994 extensions 
 
911
  inappropriate-modification(5), single-valued-attribute(6)
 
912
}(0..ub-error-reasons)
 
913
 
 
914
-- 
 
915
auto-action-request-error ABSTRACT-ERROR ::= {
 
916
  PARAMETER
 
917
    SET {problems
 
918
           [0]  SET SIZE (1..ub-auto-registrations) OF
 
919
                  SET {problem  [0]  AutoActionRequestProblem,
 
920
                       type     [1]  AUTO-ACTION.&id({AutoActionTable})
 
921
                  }}
 
922
  CODE       err-auto-action-request-error
 
923
}
 
924
 
 
925
AutoActionRequestProblem ::= INTEGER {
 
926
  unavailable-auto-action-type(0),
 
927
  auto-action-type-not-subscribed(1),
 
928
  -- 1994 extension 
 
929
  not-willing-to-perform(2)}(0..ub-error-reasons)
 
930
 
 
931
-- 
 
932
delete-error ABSTRACT-ERROR ::= {
 
933
  PARAMETER
 
934
    SET {problems
 
935
           [0]  SET SIZE (1..ub-messages) OF
 
936
                  SET {problem          [0]  DeleteProblem,
 
937
                       sequence-number  [1]  SequenceNumber},
 
938
         -- 1994 extension 
 
939
         entries-deleted
 
940
           [1]  SET SIZE (1..ub-messages) OF SequenceNumber OPTIONAL}
 
941
  CODE       err-delete-error
 
942
}
 
943
 
 
944
DeleteProblem ::= INTEGER {
 
945
  child-entry-specified(0),
 
946
  delete-restriction-problem(1),
 
947
  -- 1994 extensions 
 
948
  new-entry-specified(2), entry-class-restriction(3), stored-message-exists(4)
 
949
}(0..ub-error-reasons)
 
950
 
 
951
-- 
 
952
fetch-restriction-error ABSTRACT-ERROR ::= {
 
953
  PARAMETER
 
954
    SET {problems
 
955
           [0]  SET SIZE (1..ub-default-registrations) OF
 
956
                  SET {problem      [3]  FetchRestrictionProblem,
 
957
                       restriction
 
958
                         CHOICE {content-type      [0]  OBJECT IDENTIFIER,
 
959
                                 eit               [1]  MS-EITs,
 
960
                                 attribute-length  [2]  INTEGER}}}
 
961
  CODE       err-fetch-restriction-error
 
962
}
 
963
 
 
964
FetchRestrictionProblem ::= INTEGER {
 
965
  content-type-problem(1), eit-problem(2), maximum-length-problem(3)
 
966
}(0..ub-error-reasons)
 
967
 
 
968
-- 
 
969
invalid-parameters-error ABSTRACT-ERROR ::= {
 
970
  PARAMETER  NULL
 
971
  CODE       err-invalid-parameters-error
 
972
}
 
973
 
 
974
-- 
 
975
range-error ABSTRACT-ERROR ::= {
 
976
  PARAMETER  SET {problem  [0]  RangeProblem}
 
977
  CODE       err-range-error
 
978
}
 
979
 
 
980
RangeProblem ::= INTEGER {reversed(0)}(0..ub-error-reasons)
 
981
 
 
982
-- 
 
983
sequence-number-error ABSTRACT-ERROR ::= {
 
984
  PARAMETER
 
985
    SET {problems
 
986
           [1]  SET SIZE (1..ub-messages) OF
 
987
                  SET {problem          [0]  SequenceNumberProblem,
 
988
                       sequence-number  [1]  SequenceNumber}}
 
989
  CODE       err-sequence-number-error
 
990
}
 
991
 
 
992
SequenceNumberProblem ::= INTEGER {no-such-entry(0)}(0..ub-error-reasons)
 
993
 
 
994
-- 
 
995
service-error ABSTRACT-ERROR ::= {
 
996
  PARAMETER  ServiceErrorParameter
 
997
  CODE       err-service-error
 
998
}
 
999
 
 
1000
ServiceErrorParameter ::= SET {
 
1001
  problem                    [0]  ServiceProblem,
 
1002
  -- 1994 extension 
 
1003
  supplementary-information
 
1004
    [1]  GeneralString(SIZE (1..ub-supplementary-info-length)) OPTIONAL
 
1005
}
 
1006
 
 
1007
ServiceProblem ::= INTEGER {busy(0), unavailable(1), unwilling-to-perform(2)
 
1008
}(0..ub-error-reasons)
 
1009
 
 
1010
-- 
 
1011
message-group-error ABSTRACT-ERROR ::= {
 
1012
  PARAMETER  MessageGroupErrorParameter
 
1013
  CODE       err-message-group-error
 
1014
}
 
1015
 
 
1016
MessageGroupErrorParameter ::= SET {
 
1017
  problem  [0]  MessageGroupProblem,
 
1018
  name     [1]  MessageGroupName
 
1019
}
 
1020
 
 
1021
MessageGroupProblem ::= INTEGER {
 
1022
  name-not-registered(0), name-already-registered(1), parent-not-registered(2),
 
1023
  group-not-empty(3), name-in-use(4), child-group-registered(5),
 
1024
  group-depth-exceeded(6)}(0..ub-error-reasons)
 
1025
 
 
1026
-- 
 
1027
ms-extension-error ABSTRACT-ERROR ::= {
 
1028
  PARAMETER  MSExtensionErrorParameter
 
1029
  CODE       err-ms-extension-error
 
1030
}
 
1031
 
 
1032
MSExtensionErrorParameter ::= CHOICE {
 
1033
  ms-extension-problem  [0]  MSExtensionItem,
 
1034
  unknown-ms-extension  [1]  OBJECT IDENTIFIER
 
1035
}
 
1036
 
 
1037
-- 
 
1038
register-ms-error ABSTRACT-ERROR ::= {
 
1039
  PARAMETER
 
1040
    SET {problem            [0]  RegistrationProblem,
 
1041
         registration-type  [1]  RegistrationTypes}
 
1042
  CODE       err-register-ms-error
 
1043
}
 
1044
 
 
1045
RegistrationProblem ::= ENUMERATED {
 
1046
  registration-not-supported(0), registration-improperly-specified(1),
 
1047
  registration-limit-exceeded(2), ... -- For future extension additions --
 
1048
  }
 
1049
 
 
1050
-- 
 
1051
modify-error ABSTRACT-ERROR ::= {
 
1052
  PARAMETER  ModifyErrorParameter
 
1053
  CODE       err-modify-error
 
1054
}
 
1055
 
 
1056
ModifyErrorParameter ::= SET {
 
1057
  entries-modified
 
1058
    [0]  SEQUENCE SIZE (1..ub-messages) OF SequenceNumber OPTIONAL,
 
1059
  failing-entry        [1]  SequenceNumber,
 
1060
  modification-number  [2]  INTEGER,
 
1061
  problem              [3]  ModifyProblem
 
1062
}
 
1063
 
 
1064
ModifyProblem ::= INTEGER {
 
1065
  attribute-not-present(0), value-not-present(1),
 
1066
  attribute-or-value-already-exists(2), invalid-position(3),
 
1067
  modify-restriction-problem(4)}(0..ub-error-reasons)
 
1068
 
 
1069
-- 
 
1070
entry-class-error ABSTRACT-ERROR ::= {
 
1071
  PARAMETER  EntryClassErrorParameter
 
1072
  CODE       err-entry-class-error
 
1073
}
 
1074
 
 
1075
EntryClassErrorParameter ::= SET {
 
1076
  entry-class  [0]  EntryClass,
 
1077
  problem
 
1078
    [1]  BIT STRING {unsupported-entry-class(0), entry-class-not-subscribed(1),
 
1079
                     inappropriate-entry-class(2)}
 
1080
}
 
1081
 
 
1082
END -- of MS Abstract Service
 
1083
 
 
1084
-- Generated by Asnp, the ASN.1 pretty-printer of France Telecom R&D
 
1085