2502 lines
84 KiB
Groff
2502 lines
84 KiB
Groff
-- $Id$
|
|
-- Module MTSAbstractService (X.411:06/1999)
|
|
MTSAbstractService {joint-iso-itu-t mhs(6) mts(3) modules(0)
|
|
mts-abstract-service(1) version-1999(1)} DEFINITIONS IMPLICIT TAGS ::=
|
|
BEGIN
|
|
|
|
-- Prologue
|
|
-- Exports everything
|
|
IMPORTS
|
|
-- Remote Operations
|
|
CONNECTION-PACKAGE, CONTRACT, ERROR, OPERATION, OPERATION-PACKAGE,
|
|
ROS-OBJECT-CLASS
|
|
--==
|
|
FROM Remote-Operations-Information-Objects {joint-iso-itu-t
|
|
remote-operations(4) informationObjects(5) version1(0)}
|
|
emptyUnbind
|
|
--==
|
|
FROM Remote-Operations-Useful-Definitions {joint-iso-itu-t
|
|
remote-operations(4) useful-definitions(7) version1(0)}
|
|
-- MTA Abstract Service
|
|
internal-trace-information, trace-information
|
|
--==
|
|
FROM MTAAbstractService {joint-iso-itu-t mhs(6) mts(3) modules(0)
|
|
mta-abstract-service(2) version-1999(1)}
|
|
-- MS Abstract Service Extension
|
|
forwarding-request
|
|
--==
|
|
FROM MSAbstractService {joint-iso-itu-t mhs(6) ms(4) modules(0)
|
|
abstract-service(1) version-1999(1)}
|
|
-- IPM Information Objects
|
|
IPMPerRecipientEnvelopeExtensions
|
|
--==
|
|
FROM IPMSInformationObjects {joint-iso-itu-t mhs(6) ipms(1) modules(0)
|
|
information-objects(2) version-1999(1)}
|
|
-- Object Identifiers
|
|
id-att-physicalRendition-basic, id-cp-mts-connect, id-ct-mts-access,
|
|
id-ct-mts-forced-access, id-ot-mts, id-ot-mts-user, id-pt-administration,
|
|
id-pt-delivery, id-pt-submission, id-tok-asymmetricToken
|
|
--==
|
|
FROM MTSObjectIdentifiers {joint-iso-itu-t mhs(6) mts(3) modules(0)
|
|
object-identifiers(0) version-1999(1)}
|
|
-- Operation and Error Codes
|
|
err-control-violates-registration,
|
|
err-deferred-delivery-cancellation-rejected, err-delivery-control-violated,
|
|
err-element-of-service-not-subscribed, err-inconsistent-request,
|
|
err-message-submission-identifier-invalid,
|
|
err-new-credentials-unacceptable,
|
|
err-old-credentials-incorrectly-specified, err-operation-refused,
|
|
err-originator-invalid, err-recipient-improperly-specified,
|
|
err-register-rejected, err-remote-bind-error, err-security-error,
|
|
err-submission-control-violated, err-unsupported-critical-function,
|
|
op-cancel-deferred-delivery, op-change-credentials, op-delivery-control,
|
|
op-message-delivery, op-message-submission, op-probe-submission,
|
|
op-register, op-report-delivery, op-submission-control
|
|
--==
|
|
FROM MTSAccessProtocol {joint-iso-itu-t mhs(6) protocols(0) modules(0)
|
|
mts-access-protocol(1) version-1999(1)}
|
|
-- Directory Definitions
|
|
Name
|
|
--==
|
|
FROM InformationFramework {joint-iso-itu-t ds(5) module(1)
|
|
informationFramework(1) 3}
|
|
PresentationAddress
|
|
--==
|
|
FROM SelectedAttributeTypes {joint-iso-itu-t ds(5) module(1)
|
|
selectedAttributeTypes(5) 3}
|
|
ALGORITHM, AlgorithmIdentifier, Certificates, ENCRYPTED{}
|
|
-- , SIGNATURE{}, SIGNED{}
|
|
--==
|
|
FROM AuthenticationFramework {joint-iso-itu-t ds(5) module(1)
|
|
authenticationFramework(7) 3}
|
|
-- Certificate Extensions
|
|
CertificateAssertion
|
|
--==
|
|
FROM CertificateExtensions {joint-iso-itu-t ds(5) module(1)
|
|
certificateExtensions(26) 0}
|
|
-- Upper Bounds
|
|
ub-bit-options, ub-built-in-content-type,
|
|
ub-built-in-encoded-information-types, ub-certificates,
|
|
ub-common-name-length, ub-content-id-length, ub-content-length,
|
|
ub-content-types, ub-country-name-alpha-length,
|
|
ub-country-name-numeric-length, ub-deliverable-class, ub-diagnostic-codes,
|
|
ub-dl-expansions, ub-domain-defined-attributes,
|
|
ub-domain-defined-attribute-type-length,
|
|
ub-domain-defined-attribute-value-length, ub-domain-name-length,
|
|
ub-encoded-information-types, ub-extension-attributes, ub-extension-types,
|
|
ub-e163-4-number-length, ub-e163-4-sub-address-length,
|
|
ub-generation-qualifier-length, ub-given-name-length, ub-initials-length,
|
|
ub-integer-options, ub-local-id-length, ub-mta-name-length,
|
|
ub-mts-user-types, ub-numeric-user-id-length, ub-organization-name-length,
|
|
ub-organizational-units, ub-organizational-unit-name-length,
|
|
ub-orig-and-dl-expansions, ub-password-length, ub-pds-name-length,
|
|
ub-pds-parameter-length, ub-pds-physical-address-lines,
|
|
ub-postal-code-length, ub-privacy-mark-length, ub-queue-size,
|
|
ub-reason-codes, ub-recipients, ub-recipient-number-for-advice-length,
|
|
ub-redirections, ub-redirection-classes, ub-restrictions,
|
|
ub-security-categories, ub-security-labels, ub-security-problems,
|
|
ub-supplementary-info-length, ub-surname-length, ub-terminal-id-length,
|
|
ub-tsap-id-length, ub-unformatted-address-length,
|
|
ub-universal-generation-qualifier-length, ub-universal-given-name-length,
|
|
ub-universal-initials-length, ub-universal-surname-length,
|
|
ub-x121-address-length
|
|
--==
|
|
FROM MTSUpperBounds {joint-iso-itu-t mhs(6) mts(3) modules(0)
|
|
upper-bounds(3) version-1999(1)};
|
|
|
|
-- operationObject1 OPERATION ::= {LINKED {operationObject2}
|
|
-- }
|
|
|
|
-- operationObject2 OPERATION ::= {LINKED {operationObject3}
|
|
-- }
|
|
|
|
-- operationObject3 OPERATION ::= {LINKED {operationObject4}
|
|
-- }
|
|
|
|
-- operationObject4 OPERATION ::= {LINKED {...}
|
|
-- }
|
|
|
|
-- Objects
|
|
MHS-OBJECT ::= ROS-OBJECT-CLASS
|
|
|
|
mts MHS-OBJECT ::= {
|
|
INITIATES {mts-forced-access-contract}
|
|
RESPONDS {mts-access-contract}
|
|
ID id-ot-mts
|
|
}
|
|
|
|
mts-user MHS-OBJECT ::= {
|
|
INITIATES {mts-access-contract}
|
|
RESPONDS {mts-forced-access-contract}
|
|
ID id-ot-mts-user
|
|
}
|
|
|
|
-- Contracts
|
|
mts-access-contract CONTRACT ::= {
|
|
CONNECTION mts-connect
|
|
INITIATOR CONSUMER OF {submission | delivery | administration}
|
|
ID id-ct-mts-access
|
|
}
|
|
|
|
mts-forced-access-contract CONTRACT ::= {
|
|
CONNECTION mts-connect
|
|
RESPONDER CONSUMER OF {submission | delivery | administration}
|
|
ID id-ct-mts-forced-access
|
|
}
|
|
|
|
-- Connection package
|
|
mts-connect CONNECTION-PACKAGE ::= {
|
|
BIND mts-bind
|
|
UNBIND mts-unbind
|
|
ID id-cp-mts-connect
|
|
}
|
|
|
|
-- Ports
|
|
PORT ::= OPERATION-PACKAGE
|
|
|
|
submission PORT ::= {
|
|
OPERATIONS {operationObject1, ...}
|
|
CONSUMER INVOKES
|
|
{message-submission | probe-submission | cancel-deferred-delivery, ...}
|
|
SUPPLIER INVOKES {submission-control, ...}
|
|
ID id-pt-submission
|
|
}
|
|
|
|
delivery PORT ::= {
|
|
OPERATIONS {operationObject1, ...}
|
|
CONSUMER INVOKES {delivery-control, ...}
|
|
SUPPLIER INVOKES {message-delivery | report-delivery, ...}
|
|
ID id-pt-delivery
|
|
}
|
|
|
|
administration PORT ::= {
|
|
OPERATIONS {change-credentials, ...}
|
|
CONSUMER INVOKES {register, ...}
|
|
SUPPLIER INVOKES {operationObject1, ...}
|
|
ID id-pt-administration
|
|
}
|
|
|
|
-- MTS-bind and MTS-unbind
|
|
ABSTRACT-OPERATION ::= OPERATION
|
|
|
|
ABSTRACT-ERROR ::= ERROR
|
|
|
|
mts-bind --ABSTRACT- -- OPERATION ::= {
|
|
ARGUMENT MTSBindArgument
|
|
RESULT MTSBindResult
|
|
ERRORS {mts-bind-error}
|
|
CODE op-ros-bind -- WS: internal operation code
|
|
}
|
|
|
|
MTSBindArgument ::= SET {
|
|
initiator-name ObjectName,
|
|
messages-waiting [1] EXPLICIT MessagesWaiting OPTIONAL,
|
|
initiator-credentials [2] InitiatorCredentials,
|
|
security-context [3] SecurityContext OPTIONAL,
|
|
...,
|
|
extensions
|
|
[5] SET OF ExtensionField{{MTSBindExtensions}} DEFAULT {}
|
|
}
|
|
|
|
MTSBindExtensions EXTENSION ::= {PrivateExtensions, ...}
|
|
|
|
-- May contain private extensions and future standardised extensions
|
|
MTSBindResult ::= SET {
|
|
responder-name ObjectName,
|
|
messages-waiting [1] EXPLICIT MessagesWaiting OPTIONAL,
|
|
responder-credentials [2] ResponderCredentials,
|
|
...,
|
|
extensions
|
|
[5] SET OF ExtensionField{{MTSBindResultExtensions}} DEFAULT {}
|
|
}
|
|
|
|
MTSBindResultExtensions EXTENSION ::= {PrivateExtensions, ...}
|
|
|
|
-- May contain private extensions and future standardised extensions
|
|
mts-bind-error -- ABSTRACT- -- ERROR ::= {
|
|
PARAMETER
|
|
INTEGER {busy(0), authentication-error(2), unacceptable-dialogue-mode(3),
|
|
unacceptable-security-context(4),
|
|
inadequate-association-confidentiality(5)}(0..ub-integer-options)
|
|
CODE err-ros-bind -- WS: internal error code
|
|
}
|
|
|
|
mts-unbind ABSTRACT-OPERATION ::= emptyUnbind
|
|
|
|
-- Association Control Parameters
|
|
ObjectName ::= CHOICE {
|
|
user-agent ORAddressAndOptionalDirectoryName,
|
|
mTA [0] MTAName,
|
|
message-store [4] ORAddressAndOptionalDirectoryName
|
|
}
|
|
|
|
MessagesWaiting ::= SET {
|
|
urgent [0] DeliveryQueue,
|
|
normal [1] DeliveryQueue,
|
|
non-urgent [2] DeliveryQueue
|
|
}
|
|
|
|
DeliveryQueue ::= SET {
|
|
messages [0] INTEGER(0..ub-queue-size),
|
|
octets [1] INTEGER(0..ub-content-length) OPTIONAL
|
|
}
|
|
|
|
InitiatorCredentials ::= Credentials
|
|
|
|
ResponderCredentials ::= Credentials
|
|
|
|
Credentials ::= CHOICE {
|
|
simple Password,
|
|
strong [0] StrongCredentials,
|
|
...,
|
|
protected [1] ProtectedPassword
|
|
}
|
|
|
|
Password ::= CHOICE {
|
|
ia5-string IA5String(SIZE (0..ub-password-length)),
|
|
octet-string OCTET STRING(SIZE (0..ub-password-length))
|
|
}
|
|
|
|
StrongCredentials ::= SET {
|
|
bind-token [0] Token OPTIONAL,
|
|
certificate [1] Certificates OPTIONAL,
|
|
...,
|
|
certificate-selector [2] CertificateAssertion OPTIONAL
|
|
}
|
|
|
|
ProtectedPassword ::= SET {
|
|
signature
|
|
-- SIGNATURE{SET {password Password,
|
|
-- time1 [0] UTCTime OPTIONAL,
|
|
-- time2 [1] UTCTime OPTIONAL,
|
|
-- random1 [2] BIT STRING OPTIONAL,
|
|
-- random2 [3] BIT STRING OPTIONAL}},
|
|
Signature,
|
|
time1 [0] UTCTime OPTIONAL,
|
|
time2 [1] UTCTime OPTIONAL,
|
|
random1 [2] BIT STRING OPTIONAL,
|
|
random2 [3] BIT STRING OPTIONAL
|
|
}
|
|
|
|
Signature ::= SEQUENCE {
|
|
algorithmIdentifier AlgorithmIdentifier,
|
|
encrypted BIT STRING
|
|
}
|
|
|
|
SecurityContext ::= SET SIZE (1..ub-security-labels) OF SecurityLabel
|
|
|
|
-- Submission Port
|
|
message-submission -- ABSTRACT- -- OPERATION ::= {
|
|
ARGUMENT MessageSubmissionArgument
|
|
RESULT MessageSubmissionResult
|
|
ERRORS
|
|
{submission-control-violated | element-of-service-not-subscribed |
|
|
originator-invalid | recipient-improperly-specified |
|
|
inconsistent-request | security-error | unsupported-critical-function |
|
|
remote-bind-error}
|
|
LINKED {operationObject1, ...}
|
|
INVOKE PRIORITY {4 -- | 6 | 7 -- }
|
|
CODE op-message-submission
|
|
}
|
|
|
|
MessageSubmissionArgument ::= SEQUENCE {
|
|
envelope MessageSubmissionEnvelope,
|
|
content Content
|
|
}
|
|
|
|
MessageSubmissionResult ::= SET {
|
|
message-submission-identifier MessageSubmissionIdentifier,
|
|
message-submission-time [0] MessageSubmissionTime,
|
|
content-identifier ContentIdentifier OPTIONAL,
|
|
extensions
|
|
[1] SET OF ExtensionField{{MessageSubmissionResultExtensions}} DEFAULT {}
|
|
}
|
|
|
|
MessageSubmissionResultExtensions EXTENSION ::=
|
|
{-- May contain the following extensions, private extensions, and future standardised extensions,
|
|
-- at most one instance of each extension type:
|
|
originating-MTA-certificate | proof-of-submission | PrivateExtensions,
|
|
...}
|
|
|
|
probe-submission -- ABSTRACT- -- OPERATION ::= {
|
|
ARGUMENT ProbeSubmissionArgument
|
|
RESULT ProbeSubmissionResult
|
|
ERRORS
|
|
{submission-control-violated | element-of-service-not-subscribed |
|
|
originator-invalid | recipient-improperly-specified |
|
|
inconsistent-request | security-error | unsupported-critical-function |
|
|
remote-bind-error}
|
|
LINKED {operationObject1, ...}
|
|
INVOKE PRIORITY {5}
|
|
CODE op-probe-submission
|
|
}
|
|
|
|
ProbeSubmissionArgument ::= ProbeSubmissionEnvelope
|
|
|
|
ProbeSubmissionResult ::= SET {
|
|
probe-submission-identifier ProbeSubmissionIdentifier,
|
|
probe-submission-time [0] ProbeSubmissionTime,
|
|
content-identifier ContentIdentifier OPTIONAL,
|
|
extensions
|
|
[1] SET OF ExtensionField{{ProbeResultExtensions}} DEFAULT {}
|
|
}
|
|
|
|
ProbeResultExtensions EXTENSION ::= {PrivateExtensions, ...}
|
|
|
|
-- May contain private extensions and future standardised extensions,
|
|
-- at most one instance of each extension type
|
|
cancel-deferred-delivery -- ABSTRACT- -- OPERATION ::= {
|
|
ARGUMENT CancelDeferredDeliveryArgument
|
|
RESULT CancelDeferredDeliveryResult
|
|
ERRORS
|
|
{deferred-delivery-cancellation-rejected |
|
|
message-submission-identifier-invalid | remote-bind-error}
|
|
LINKED {operationObject1, ...}
|
|
INVOKE PRIORITY {3}
|
|
CODE op-cancel-deferred-delivery
|
|
}
|
|
|
|
CancelDeferredDeliveryArgument ::= MessageSubmissionIdentifier
|
|
|
|
CancelDeferredDeliveryResult ::= NULL
|
|
|
|
submission-control -- ABSTRACT- -- OPERATION ::= {
|
|
ARGUMENT SubmissionControlArgument
|
|
RESULT SubmissionControlResult
|
|
ERRORS {security-error | remote-bind-error}
|
|
LINKED {operationObject1, ...}
|
|
INVOKE PRIORITY {3}
|
|
CODE op-submission-control
|
|
}
|
|
|
|
SubmissionControlArgument ::= SubmissionControls
|
|
|
|
SubmissionControlResult ::= Waiting
|
|
|
|
submission-control-violated -- ABSTRACT- -- ERROR ::= {
|
|
PARAMETER NULL
|
|
CODE err-submission-control-violated
|
|
}
|
|
|
|
element-of-service-not-subscribed -- ABSTRACT- -- ERROR ::= {
|
|
PARAMETER NULL
|
|
CODE err-element-of-service-not-subscribed
|
|
}
|
|
|
|
deferred-delivery-cancellation-rejected -- ABSTRACT- -- ERROR ::= {
|
|
PARAMETER NULL
|
|
CODE err-deferred-delivery-cancellation-rejected
|
|
}
|
|
|
|
originator-invalid -- ABSTRACT- -- ERROR ::= {
|
|
PARAMETER NULL
|
|
CODE err-originator-invalid
|
|
}
|
|
|
|
recipient-improperly-specified -- ABSTRACT- -- ERROR ::= {
|
|
PARAMETER ImproperlySpecifiedRecipients
|
|
CODE err-recipient-improperly-specified
|
|
}
|
|
|
|
ImproperlySpecifiedRecipients ::=
|
|
SEQUENCE SIZE (1..ub-recipients) OF RecipientName
|
|
|
|
message-submission-identifier-invalid -- ABSTRACT- -- ERROR ::= {
|
|
PARAMETER NULL
|
|
CODE err-message-submission-identifier-invalid
|
|
}
|
|
|
|
inconsistent-request -- ABSTRACT- -- ERROR ::= {
|
|
PARAMETER NULL
|
|
CODE err-inconsistent-request
|
|
}
|
|
|
|
security-error -- ABSTRACT- -- ERROR ::= {
|
|
PARAMETER SecurityProblem
|
|
CODE err-security-error
|
|
}
|
|
|
|
SecurityProblem ::= INTEGER {
|
|
assemby-instructions-conflict-with-security-services(0),
|
|
authentication-problem(1), authentication-failure-on-subject-message(2),
|
|
confidentiality-association-problem(3), decryption-failed(4),
|
|
decryption-key-unobtainable(5), failure-of-proof-of-message(6),
|
|
forbidden-user-security-label-register(7),
|
|
incompatible-change-with-original-security-context(8),
|
|
integrity-failure-on-subject-message(9), invalid-security-label(10),
|
|
invalid-security-label-update(11), key-failure(12),
|
|
mandatory-parameter-absence(13), operation-security-failure(14),
|
|
redirection-prohibited(15), refused-alternate-recipient-name(16),
|
|
repudiation-failure-of-message(17),
|
|
responder-credentials-checking-problem(18), security-context-failure(19),
|
|
security-context-problem(20), security-policy-violation(21),
|
|
security-services-refusal(22), token-decryption-failed(23), token-error(24),
|
|
unable-to-aggregate-security-labels(25), unauthorised-dl-name(26),
|
|
unauthorised-entry-class(27),
|
|
unauthorised-originally-intended-recipient-name(28),
|
|
unauthorised-originator-name(29), unauthorised-recipient-name(30),
|
|
unauthorised-security-label-update(31), unauthorised-user-name(32),
|
|
unknown-security-label(33), unsupported-algorithm-identifier(34),
|
|
unsupported-security-policy(35)}(0..ub-security-problems)
|
|
|
|
unsupported-critical-function -- ABSTRACT- -- ERROR ::= {
|
|
PARAMETER NULL
|
|
CODE err-unsupported-critical-function
|
|
}
|
|
|
|
remote-bind-error -- ABSTRACT- -- ERROR ::= {
|
|
PARAMETER NULL
|
|
CODE err-remote-bind-error
|
|
}
|
|
|
|
-- Submission Port Parameters
|
|
MessageSubmissionIdentifier ::= MTSIdentifier
|
|
|
|
MessageSubmissionTime ::= Time
|
|
|
|
ProbeSubmissionIdentifier ::= MTSIdentifier
|
|
|
|
ProbeSubmissionTime ::= Time
|
|
|
|
SubmissionControls ::=
|
|
Controls
|
|
(WITH COMPONENTS {
|
|
...,
|
|
permissible-content-types ABSENT,
|
|
permissible-encoded-information-types ABSENT
|
|
})
|
|
|
|
Waiting ::= SET {
|
|
waiting-operations [0] Operations DEFAULT {},
|
|
waiting-messages [1] WaitingMessages DEFAULT {},
|
|
waiting-content-types
|
|
[2] SET SIZE (0..ub-content-types) OF ContentType DEFAULT {},
|
|
waiting-encoded-information-types EncodedInformationTypes OPTIONAL
|
|
}
|
|
|
|
Operations ::= BIT STRING {
|
|
probe-submission-or-report-delivery(0),
|
|
message-submission-or-message-delivery(1)}(SIZE (0..ub-bit-options))
|
|
|
|
-- holding 'one', not-holding 'zero'
|
|
WaitingMessages ::= BIT STRING {
|
|
long-content(0), low-priority(1), other-security-labels(2)
|
|
}(SIZE (0..ub-bit-options))
|
|
|
|
-- Delivery Port
|
|
message-delivery -- ABSTRACT- -- OPERATION ::= {
|
|
ARGUMENT MessageDeliveryArgument
|
|
RESULT MessageDeliveryResult
|
|
ERRORS
|
|
{delivery-control-violated | security-error |
|
|
unsupported-critical-function}
|
|
LINKED {operationObject1, ...}
|
|
INVOKE PRIORITY {4 -- | 6 | 7 --}
|
|
CODE op-message-delivery
|
|
}
|
|
|
|
MessageDeliveryArgument ::= SEQUENCE {
|
|
COMPONENTS OF MessageDeliveryEnvelope,
|
|
content Content
|
|
}
|
|
|
|
MessageDeliveryResult ::= SET {
|
|
recipient-certificate [0] RecipientCertificate OPTIONAL,
|
|
proof-of-delivery [1] IMPLICIT ProofOfDelivery OPTIONAL,
|
|
...,
|
|
extensions
|
|
[2] SET OF ExtensionField{{MessageDeliveryResultExtensions}} DEFAULT {}
|
|
}
|
|
|
|
MessageDeliveryResultExtensions EXTENSION ::= {PrivateExtensions, ...}
|
|
|
|
-- May contain private extensions and future standardised extensions
|
|
report-delivery -- ABSTRACT- -- OPERATION ::= {
|
|
ARGUMENT ReportDeliveryArgument
|
|
RESULT ReportDeliveryResult
|
|
ERRORS
|
|
{delivery-control-violated | security-error |
|
|
unsupported-critical-function}
|
|
LINKED {operationObject1, ...}
|
|
INVOKE PRIORITY {5}
|
|
CODE op-report-delivery
|
|
}
|
|
|
|
ReportDeliveryArgument ::= SET {
|
|
COMPONENTS OF ReportDeliveryEnvelope,
|
|
returned-content [0] Content OPTIONAL
|
|
}
|
|
|
|
ReportDeliveryResult ::= CHOICE {
|
|
empty-result NULL,
|
|
...,
|
|
extensions
|
|
SET SIZE (1..MAX) OF ExtensionField{{ReportDeliveryResultExtensions}}
|
|
}
|
|
|
|
ReportDeliveryResultExtensions EXTENSION ::= {PrivateExtensions, ...}
|
|
|
|
-- May contain private extensions and future standardised extensions
|
|
delivery-control -- ABSTRACT- -- OPERATION ::= {
|
|
ARGUMENT DeliveryControlArgument
|
|
RESULT DeliveryControlResult
|
|
ERRORS
|
|
{control-violates-registration | security-error | operation-refused}
|
|
LINKED {operationObject1, ...}
|
|
INVOKE PRIORITY {3}
|
|
CODE op-delivery-control
|
|
}
|
|
|
|
DeliveryControlArgument ::= SET {
|
|
-- COMPONENTS OF DeliveryControls,
|
|
restrict [0] BOOLEAN DEFAULT TRUE,
|
|
-- update 'TRUE', remove 'FALSE'
|
|
permissible-operations [1] Operations OPTIONAL,
|
|
permissible-maximum-content-length [2] ContentLength OPTIONAL,
|
|
permissible-lowest-priority Priority OPTIONAL,
|
|
permissible-content-types [4] ContentTypes OPTIONAL,
|
|
permissible-encoded-information-types
|
|
PermissibleEncodedInformationTypes OPTIONAL,
|
|
permissible-security-context [5] SecurityContext OPTIONAL,
|
|
extensions
|
|
[6] SET OF ExtensionField{{DeliveryControlExtensions}} DEFAULT {}
|
|
}
|
|
|
|
DeliveryControlExtensions EXTENSION ::= {PrivateExtensions, ...}
|
|
|
|
-- May contain private extensions and future standardised extensions
|
|
DeliveryControlResult ::= SET {
|
|
COMPONENTS OF Waiting,
|
|
extensions
|
|
[6] SET OF ExtensionField{{DeliveryControlResultExtensions}} DEFAULT {}
|
|
}
|
|
|
|
DeliveryControlResultExtensions EXTENSION ::= {PrivateExtensions, ...}
|
|
|
|
-- May contain private extensions and future standardised extensions
|
|
delivery-control-violated -- ABSTRACT- -- ERROR ::= {
|
|
PARAMETER NULL
|
|
CODE err-delivery-control-violated
|
|
}
|
|
|
|
control-violates-registration -- ABSTRACT- -- ERROR ::= {
|
|
PARAMETER NULL
|
|
CODE err-control-violates-registration
|
|
}
|
|
|
|
operation-refused -- ABSTRACT- -- ERROR ::= {
|
|
PARAMETER RefusedOperation
|
|
CODE err-operation-refused
|
|
}
|
|
|
|
RefusedOperation ::= SET {
|
|
refused-argument
|
|
CHOICE {built-in-argument [1] RefusedArgument,
|
|
refused-extension EXTENSION.&id},
|
|
refusal-reason [2] RefusalReason
|
|
}
|
|
|
|
RefusedArgument ::= INTEGER {
|
|
user-name(0), user-address(1), deliverable-content-types(2),
|
|
deliverable-maximum-content-length(3),
|
|
deliverable-encoded-information-types-constraints(4),
|
|
deliverable-security-labels(5), recipient-assigned-redirections(6),
|
|
restricted-delivery(7),
|
|
retrieve-registrations(8), -- value 9 reserved for possible future extension to Register arguments
|
|
restrict(10), permissible-operations(11), permissible-lowest-priority(12),
|
|
permissible-encoded-information-types(13), permissible-content-types(14),
|
|
permissible-maximum-content-length(15), permissible-security-context(16)
|
|
}(0..ub-integer-options)
|
|
|
|
RefusalReason ::= INTEGER {
|
|
facility-unavailable(0), facility-not-subscribed(1),
|
|
parameter-unacceptable(2)}(0..ub-integer-options)
|
|
|
|
-- Delivery Port Parameters
|
|
RecipientCertificate ::= Certificates
|
|
|
|
ProofOfDelivery ::= Signature
|
|
-- SIGNATURE
|
|
-- {SEQUENCE {algorithm-identifier
|
|
-- ProofOfDeliveryAlgorithmIdentifier,
|
|
-- delivery-time MessageDeliveryTime,
|
|
-- this-recipient-name ThisRecipientName,
|
|
-- originally-intended-recipient-name
|
|
-- OriginallyIntendedRecipientName OPTIONAL,
|
|
-- content Content,
|
|
-- content-identifier ContentIdentifier OPTIONAL,
|
|
-- message-security-label
|
|
-- MessageSecurityLabel OPTIONAL}}
|
|
|
|
ProofOfDeliveryAlgorithmIdentifier ::= AlgorithmIdentifier
|
|
|
|
DeliveryControls ::= Controls
|
|
|
|
Controls ::= SET {
|
|
restrict [0] BOOLEAN DEFAULT TRUE,
|
|
-- update 'TRUE', remove 'FALSE'
|
|
permissible-operations [1] Operations OPTIONAL,
|
|
permissible-maximum-content-length [2] ContentLength OPTIONAL,
|
|
permissible-lowest-priority Priority OPTIONAL,
|
|
permissible-content-types [4] ContentTypes OPTIONAL,
|
|
permissible-encoded-information-types
|
|
PermissibleEncodedInformationTypes OPTIONAL,
|
|
permissible-security-context [5] SecurityContext OPTIONAL
|
|
}
|
|
|
|
-- Note - The Tags [0], [1] and [2] are altered for the Register operation only.
|
|
PermissibleEncodedInformationTypes ::=
|
|
EncodedInformationTypesConstraints
|
|
|
|
-- Administration Port
|
|
register -- ABSTRACT- -- OPERATION ::= {
|
|
ARGUMENT RegisterArgument
|
|
RESULT RegisterResult
|
|
ERRORS
|
|
{register-rejected | remote-bind-error | operation-refused |
|
|
security-error}
|
|
LINKED {operationObject1, ...}
|
|
INVOKE PRIORITY {5}
|
|
CODE op-register
|
|
}
|
|
|
|
RegisterArgument ::= SET {
|
|
user-name UserName OPTIONAL,
|
|
user-address [0] UserAddress OPTIONAL,
|
|
deliverable-class
|
|
SET SIZE (1..ub-deliverable-class) OF DeliverableClass OPTIONAL,
|
|
default-delivery-controls [2] EXPLICIT DefaultDeliveryControls OPTIONAL,
|
|
redirections [3] Redirections OPTIONAL,
|
|
restricted-delivery [4] RestrictedDelivery OPTIONAL,
|
|
retrieve-registrations [5] RegistrationTypes OPTIONAL,
|
|
extensions
|
|
[6] SET OF ExtensionField{{RegisterExtensions}} DEFAULT {}
|
|
}
|
|
|
|
RegisterExtensions EXTENSION ::= {PrivateExtensions, ...}
|
|
|
|
-- May contain private extensions and future standardised extensions
|
|
RegisterResult ::= CHOICE {
|
|
empty-result NULL,
|
|
non-empty-result
|
|
SET {registered-information
|
|
[0] RegisterArgument
|
|
(WITH COMPONENTS {
|
|
...,
|
|
retrieve-registrations ABSENT
|
|
}) OPTIONAL,
|
|
extensions
|
|
[1] SET OF ExtensionField{{RegisterResultExtensions}} DEFAULT {}
|
|
}
|
|
}
|
|
|
|
RegisterResultExtensions EXTENSION ::= {PrivateExtensions, ...}
|
|
|
|
-- May contain private extensions and future standardised extensions
|
|
change-credentials -- ABSTRACT- -- OPERATION ::= {
|
|
ARGUMENT ChangeCredentialsArgument
|
|
RESULT NULL
|
|
ERRORS
|
|
{new-credentials-unacceptable | old-credentials-incorrectly-specified |
|
|
remote-bind-error | security-error}
|
|
LINKED {operationObject1, ...}
|
|
INVOKE PRIORITY {5}
|
|
CODE op-change-credentials
|
|
}
|
|
|
|
ChangeCredentialsArgument ::= SET {
|
|
old-credentials [0] Credentials(WITH COMPONENTS {
|
|
simple
|
|
}),
|
|
new-credentials [1] Credentials(WITH COMPONENTS {
|
|
simple
|
|
})
|
|
}
|
|
|
|
register-rejected -- ABSTRACT- -- ERROR ::= {
|
|
PARAMETER NULL
|
|
CODE err-register-rejected
|
|
}
|
|
|
|
new-credentials-unacceptable -- ABSTRACT- -- ERROR ::= {
|
|
PARAMETER NULL
|
|
CODE err-new-credentials-unacceptable
|
|
}
|
|
|
|
old-credentials-incorrectly-specified -- ABSTRACT- -- ERROR ::= {
|
|
PARAMETER NULL
|
|
CODE err-old-credentials-incorrectly-specified
|
|
}
|
|
|
|
-- Administration Port Parameters
|
|
UserName ::= ORAddressAndOptionalDirectoryName
|
|
|
|
UserAddress ::= CHOICE {
|
|
x121
|
|
[0] SEQUENCE {x121-address
|
|
NumericString(SIZE (1..ub-x121-address-length)) OPTIONAL,
|
|
tsap-id
|
|
PrintableString(SIZE (1..ub-tsap-id-length)) OPTIONAL
|
|
},
|
|
presentation [1] PSAPAddress
|
|
}
|
|
|
|
PSAPAddress ::= PresentationAddress
|
|
|
|
DeliverableClass ::=
|
|
MessageClass
|
|
(WITH COMPONENTS {
|
|
...,
|
|
priority ABSENT,
|
|
-- The 'objects' component shall always be defaulted.
|
|
-- objects ABSENT,
|
|
-- A component with a DEFAULT clause cannot be ABSENT
|
|
applies-only-to ABSENT
|
|
})
|
|
|
|
DefaultDeliveryControls ::=
|
|
Controls
|
|
(WITH COMPONENTS {
|
|
...,
|
|
|
|
-- The 'restrict' component shall always be defaulted.
|
|
-- restrict ABSENT,
|
|
-- A component with a DEFAULT clause cannot be ABSENT
|
|
permissible-security-context ABSENT
|
|
})
|
|
|
|
Redirections ::= SEQUENCE SIZE (1..ub-redirections) OF RecipientRedirection
|
|
|
|
RecipientRedirection ::= SET {
|
|
redirection-classes
|
|
[0] SET SIZE (1..ub-redirection-classes) OF RedirectionClass OPTIONAL,
|
|
recipient-assigned-alternate-recipient
|
|
[1] RecipientAssignedAlternateRecipient OPTIONAL
|
|
}
|
|
|
|
RedirectionClass ::= MessageClass
|
|
|
|
MessageClass ::= SET {
|
|
content-types [0] ContentTypes OPTIONAL,
|
|
maximum-content-length [1] ContentLength OPTIONAL,
|
|
encoded-information-types-constraints
|
|
[2] EncodedInformationTypesConstraints OPTIONAL,
|
|
security-labels [3] SecurityContext OPTIONAL,
|
|
priority [4] SET OF Priority OPTIONAL,
|
|
objects
|
|
[5] ENUMERATED {messages(0), reports(1), both(2), ...
|
|
} DEFAULT both,
|
|
applies-only-to [6] SEQUENCE OF Restriction OPTIONAL, -- Not considered in the case of Reports
|
|
extensions
|
|
[7] SET OF ExtensionField{{MessageClassExtensions}} DEFAULT {}
|
|
}
|
|
|
|
EncodedInformationTypesConstraints ::= SEQUENCE {
|
|
unacceptable-eits [0] ExtendedEncodedInformationTypes OPTIONAL,
|
|
acceptable-eits [1] ExtendedEncodedInformationTypes OPTIONAL,
|
|
exclusively-acceptable-eits [2] ExtendedEncodedInformationTypes OPTIONAL
|
|
}
|
|
|
|
MessageClassExtensions EXTENSION ::= {PrivateExtensions, ...}
|
|
|
|
-- May contain private extensions and future standardised extensions
|
|
RecipientAssignedAlternateRecipient ::=
|
|
ORAddressAndOrDirectoryName
|
|
|
|
RestrictedDelivery ::= SEQUENCE SIZE (1..ub-restrictions) OF Restriction
|
|
|
|
Restriction ::= SET {
|
|
permitted BOOLEAN DEFAULT TRUE,
|
|
source-type
|
|
BIT STRING {originated-by(0), redirected-by(1), dl-expanded-by(2)}
|
|
DEFAULT {originated-by, redirected-by, dl-expanded-by},
|
|
source-name ExactOrPattern OPTIONAL
|
|
}
|
|
|
|
ExactOrPattern ::= CHOICE {
|
|
exact-match [0] ORName,
|
|
pattern-match [1] ORName
|
|
}
|
|
|
|
RegistrationTypes ::= SEQUENCE {
|
|
standard-parameters
|
|
[0] BIT STRING {user-name(0), user-address(1), deliverable-class(2),
|
|
default-delivery-controls(3), redirections(4),
|
|
restricted-delivery(5)} OPTIONAL,
|
|
extensions [1] SET OF EXTENSION.&id({RegisterExtensions}) OPTIONAL
|
|
}
|
|
|
|
-- Message Submission Envelope
|
|
MessageSubmissionEnvelope ::= SET {
|
|
COMPONENTS OF PerMessageSubmissionFields,
|
|
per-recipient-fields
|
|
[1] SEQUENCE SIZE (1..ub-recipients) OF
|
|
PerRecipientMessageSubmissionFields
|
|
}
|
|
|
|
PerMessageSubmissionFields ::= SET {
|
|
originator-name OriginatorName,
|
|
original-encoded-information-types OriginalEncodedInformationTypes OPTIONAL,
|
|
content-type ContentType,
|
|
content-identifier ContentIdentifier OPTIONAL,
|
|
priority Priority DEFAULT normal,
|
|
per-message-indicators PerMessageIndicators DEFAULT {},
|
|
deferred-delivery-time [0] DeferredDeliveryTime OPTIONAL,
|
|
extensions
|
|
[2] SET OF ExtensionField{{PerMessageSubmissionExtensions}} DEFAULT {}
|
|
}
|
|
|
|
PerMessageSubmissionExtensions EXTENSION ::=
|
|
{-- May contain the following extensions, private extensions, and future standardised extensions,
|
|
-- at most one instance of each extension type:
|
|
recipient-reassignment-prohibited | dl-expansion-prohibited |
|
|
conversion-with-loss-prohibited | latest-delivery-time |
|
|
originator-return-address | originator-certificate |
|
|
content-confidentiality-algorithm-identifier |
|
|
message-origin-authentication-check | message-security-label |
|
|
proof-of-submission-request | content-correlator | dl-exempted-recipients |
|
|
certificate-selectors | multiple-originator-certificates |
|
|
forwarding-request -- for MS Abstract Service only -- | PrivateExtensions,
|
|
...}
|
|
|
|
PerRecipientMessageSubmissionFields ::= SET {
|
|
recipient-name RecipientName,
|
|
originator-report-request [0] OriginatorReportRequest,
|
|
explicit-conversion [1] ExplicitConversion OPTIONAL,
|
|
extensions
|
|
[2] SET OF ExtensionField{{PerRecipientMessageSubmissionExtensions}}
|
|
DEFAULT {}
|
|
}
|
|
|
|
PerRecipientMessageSubmissionExtensions EXTENSION ::=
|
|
{-- May contain the following extensions, private extensions, and future standardised extensions,
|
|
-- at most one instance of each extension type:
|
|
originator-requested-alternate-recipient | requested-delivery-method |
|
|
physical-forwarding-prohibited | physical-forwarding-address-request |
|
|
physical-delivery-modes | registered-mail-type | recipient-number-for-advice
|
|
| physical-rendition-attributes | physical-delivery-report-request |
|
|
message-token | content-integrity-check | proof-of-delivery-request |
|
|
certificate-selectors-override | recipient-certificate |
|
|
IPMPerRecipientEnvelopeExtensions | PrivateExtensions, ...}
|
|
|
|
-- Probe Submission Envelope
|
|
ProbeSubmissionEnvelope ::= SET {
|
|
COMPONENTS OF PerProbeSubmissionFields,
|
|
per-recipient-fields
|
|
[3] SEQUENCE SIZE (1..ub-recipients) OF PerRecipientProbeSubmissionFields
|
|
}
|
|
|
|
PerProbeSubmissionFields ::= SET {
|
|
originator-name OriginatorName,
|
|
original-encoded-information-types OriginalEncodedInformationTypes OPTIONAL,
|
|
content-type ContentType,
|
|
content-identifier ContentIdentifier OPTIONAL,
|
|
content-length [0] ContentLength OPTIONAL,
|
|
per-message-indicators PerMessageIndicators DEFAULT {},
|
|
extensions
|
|
[2] SET OF ExtensionField{{PerProbeSubmissionExtensions}} DEFAULT {}
|
|
}
|
|
|
|
PerProbeSubmissionExtensions EXTENSION ::=
|
|
{-- May contain the following extensions, private extensions, and future standardised extensions,
|
|
-- at most one instance of each extension type:
|
|
recipient-reassignment-prohibited | dl-expansion-prohibited |
|
|
conversion-with-loss-prohibited | originator-certificate |
|
|
message-security-label | content-correlator |
|
|
probe-origin-authentication-check | PrivateExtensions, ...}
|
|
|
|
PerRecipientProbeSubmissionFields ::= SET {
|
|
recipient-name RecipientName,
|
|
originator-report-request [0] OriginatorReportRequest,
|
|
explicit-conversion [1] ExplicitConversion OPTIONAL,
|
|
extensions
|
|
[2] SET OF ExtensionField{{PerRecipientProbeSubmissionExtensions}}
|
|
DEFAULT {}
|
|
}
|
|
|
|
PerRecipientProbeSubmissionExtensions EXTENSION ::=
|
|
{-- May contain the following extensions, private extensions, and future standardised extensions,
|
|
-- at most one instance of each extension type:
|
|
originator-requested-alternate-recipient | requested-delivery-method |
|
|
physical-rendition-attributes | PrivateExtensions, ...}
|
|
|
|
-- Message Delivery Envelope
|
|
MessageDeliveryEnvelope ::= SEQUENCE {
|
|
message-delivery-identifier MessageDeliveryIdentifier,
|
|
message-delivery-time MessageDeliveryTime,
|
|
other-fields OtherMessageDeliveryFields
|
|
}
|
|
|
|
OtherMessageDeliveryFields ::= SET {
|
|
content-type DeliveredContentType,
|
|
originator-name DeliveredOriginatorName,
|
|
original-encoded-information-types
|
|
[1] OriginalEncodedInformationTypes OPTIONAL,
|
|
priority Priority DEFAULT normal,
|
|
delivery-flags [2] DeliveryFlags OPTIONAL,
|
|
other-recipient-names [3] OtherRecipientNames OPTIONAL,
|
|
this-recipient-name [4] ThisRecipientName,
|
|
originally-intended-recipient-name
|
|
[5] OriginallyIntendedRecipientName OPTIONAL,
|
|
converted-encoded-information-types
|
|
[6] ConvertedEncodedInformationTypes OPTIONAL,
|
|
message-submission-time [7] MessageSubmissionTime,
|
|
content-identifier [8] ContentIdentifier OPTIONAL,
|
|
extensions
|
|
[9] SET OF ExtensionField{{MessageDeliveryExtensions}} DEFAULT {}
|
|
}
|
|
|
|
MessageDeliveryExtensions EXTENSION ::=
|
|
{-- May contain the following extensions, private extensions, and future standardised extensions,
|
|
-- at most one instance of each extension type:
|
|
conversion-with-loss-prohibited | requested-delivery-method |
|
|
physical-forwarding-prohibited | physical-forwarding-address-request |
|
|
physical-delivery-modes | registered-mail-type | recipient-number-for-advice
|
|
| physical-rendition-attributes | originator-return-address |
|
|
physical-delivery-report-request | originator-certificate | message-token |
|
|
content-confidentiality-algorithm-identifier | content-integrity-check |
|
|
message-origin-authentication-check | message-security-label |
|
|
proof-of-delivery-request | dl-exempted-recipients | certificate-selectors |
|
|
certificate-selectors-override | multiple-originator-certificates |
|
|
recipient-certificate | IPMPerRecipientEnvelopeExtensions |
|
|
redirection-history | dl-expansion-history | trace-information |
|
|
internal-trace-information | PrivateExtensions, ...}
|
|
|
|
-- Report Delivery Envelope
|
|
ReportDeliveryEnvelope ::= SET {
|
|
COMPONENTS OF PerReportDeliveryFields,
|
|
per-recipient-fields
|
|
SEQUENCE SIZE (1..ub-recipients) OF PerRecipientReportDeliveryFields
|
|
}
|
|
|
|
PerReportDeliveryFields ::= SET {
|
|
subject-submission-identifier SubjectSubmissionIdentifier,
|
|
content-identifier ContentIdentifier OPTIONAL,
|
|
content-type ContentType OPTIONAL,
|
|
original-encoded-information-types OriginalEncodedInformationTypes OPTIONAL,
|
|
extensions
|
|
[1] SET OF ExtensionField{{ReportDeliveryExtensions}} DEFAULT {}
|
|
}
|
|
|
|
ReportDeliveryExtensions EXTENSION ::=
|
|
{-- May contain the following extensions, private extensions, and future standardised extensions,
|
|
-- at most one instance of each extension type:
|
|
message-security-label | content-correlator | redirection-history |
|
|
originator-and-DL-expansion-history | reporting-DL-name |
|
|
reporting-MTA-certificate | report-origin-authentication-check |
|
|
trace-information | internal-trace-information | reporting-MTA-name |
|
|
PrivateExtensions, ...}
|
|
|
|
PerRecipientReportDeliveryFields ::= SET {
|
|
actual-recipient-name [0] ActualRecipientName,
|
|
report-type [1] ReportType,
|
|
converted-encoded-information-types
|
|
ConvertedEncodedInformationTypes OPTIONAL,
|
|
originally-intended-recipient-name
|
|
[2] OriginallyIntendedRecipientName OPTIONAL,
|
|
supplementary-information [3] SupplementaryInformation OPTIONAL,
|
|
extensions
|
|
[4] SET OF ExtensionField{{PerRecipientReportDeliveryExtensions}}
|
|
DEFAULT {}
|
|
}
|
|
|
|
PerRecipientReportDeliveryExtensions EXTENSION ::=
|
|
{-- May contain the following extensions, private extensions, and future standardised extensions,
|
|
-- at most one instance of each extension type:
|
|
redirection-history | physical-forwarding-address | recipient-certificate |
|
|
proof-of-delivery | PrivateExtensions, ...}
|
|
|
|
ReportType ::= CHOICE {
|
|
delivery [0] DeliveryReport,
|
|
non-delivery [1] NonDeliveryReport
|
|
}
|
|
|
|
DeliveryReport ::= SET {
|
|
message-delivery-time [0] MessageDeliveryTime,
|
|
type-of-MTS-user [1] TypeOfMTSUser DEFAULT public
|
|
}
|
|
|
|
NonDeliveryReport ::= SET {
|
|
non-delivery-reason-code [0] NonDeliveryReasonCode,
|
|
non-delivery-diagnostic-code [1] NonDeliveryDiagnosticCode OPTIONAL
|
|
}
|
|
|
|
-- Envelope Fields
|
|
OriginatorName ::= ORAddressAndOrDirectoryName
|
|
|
|
DeliveredOriginatorName ::= ORAddressAndOptionalDirectoryName
|
|
|
|
OriginalEncodedInformationTypes ::= EncodedInformationTypes
|
|
|
|
ContentTypes ::= SET SIZE (1..ub-content-types) OF ContentType
|
|
|
|
ContentType ::= CHOICE {
|
|
built-in BuiltInContentType,
|
|
extended ExtendedContentType
|
|
}
|
|
|
|
BuiltInContentType ::= [APPLICATION 6] INTEGER {
|
|
unidentified(0),
|
|
external(1), -- identified by the object-identifier of the EXTERNAL content
|
|
interpersonal-messaging-1984(2), interpersonal-messaging-1988(22),
|
|
edi-messaging(35), voice-messaging(40)}(0..ub-built-in-content-type)
|
|
|
|
ExtendedContentType ::= OBJECT IDENTIFIER -- RELATIVE-OID
|
|
|
|
DeliveredContentType ::= CHOICE {
|
|
built-in [0] BuiltInContentType,
|
|
extended ExtendedContentType
|
|
}
|
|
|
|
ContentIdentifier ::=
|
|
[APPLICATION 10] PrintableString(SIZE (1..ub-content-id-length))
|
|
|
|
PerMessageIndicators ::= [APPLICATION 8] BIT STRING {
|
|
disclosure-of-other-recipients(0), -- disclosure-of-other-recipients-requested 'one',
|
|
|
|
-- disclosure-of-other-recipients-prohibited 'zero';
|
|
-- ignored for Probe-submission
|
|
implicit-conversion-prohibited(1), -- implicit-conversion-prohibited 'one',
|
|
|
|
-- implicit-conversion-allowed 'zero'
|
|
alternate-recipient-allowed(2), -- alternate-recipient-allowed 'one',
|
|
|
|
-- alternate-recipient-prohibited 'zero'
|
|
content-return-request(3), -- content-return-requested 'one',
|
|
|
|
-- content-return-not-requested 'zero';
|
|
-- ignored for Probe-submission
|
|
reserved(4), -- bit reserved by MOTIS 1986
|
|
bit-5(5),
|
|
bit-6(6), -- notification type-1 : bit 5 'zero' and bit 6 'one'
|
|
|
|
-- notification type-2 : bit 5 'one' and bit 6 'zero'
|
|
-- notification type-3 : bit 5 'one' and bit 6 'one'
|
|
-- the mapping between notification type 1, 2, 3
|
|
-- and the content specific notification types are defined
|
|
-- in relevant content specifications
|
|
service-message(7) -- the message content is for service purposes;
|
|
|
|
|
|
-- it may be a notification related to a service message;
|
|
-- used only by bilateral agreement --}(SIZE (0..ub-bit-options))
|
|
|
|
RecipientName ::= ORAddressAndOrDirectoryName
|
|
|
|
OriginatorReportRequest ::= BIT STRING {report(3), non-delivery-report(4)
|
|
|
|
-- at most one bit shall be 'one':
|
|
-- report bit 'one' requests a 'report';
|
|
-- non-delivery-report bit 'one' requests a 'non-delivery-report';
|
|
-- both bits 'zero' requests 'no-report' --}(SIZE (0..ub-bit-options))
|
|
|
|
ExplicitConversion ::= INTEGER {
|
|
ia5-text-to-teletex(0),
|
|
-- values 1 to 7 are no longer defined
|
|
ia5-text-to-g3-facsimile(8), ia5-text-to-g4-class-1(9),
|
|
ia5-text-to-videotex(10), teletex-to-ia5-text(11),
|
|
teletex-to-g3-facsimile(12), teletex-to-g4-class-1(13),
|
|
teletex-to-videotex(14),
|
|
-- value 15 is no longer defined
|
|
videotex-to-ia5-text(16), videotex-to-teletex(17)}(0..ub-integer-options)
|
|
|
|
DeferredDeliveryTime ::= Time
|
|
|
|
Priority ::= [APPLICATION 7] ENUMERATED {normal(0), non-urgent(1), urgent(2)}
|
|
|
|
ContentLength ::= INTEGER(0..ub-content-length)
|
|
|
|
MessageDeliveryIdentifier ::= MTSIdentifier
|
|
|
|
MessageDeliveryTime ::= Time
|
|
|
|
DeliveryFlags ::= BIT STRING {
|
|
implicit-conversion-prohibited(1) -- implicit-conversion-prohibited 'one',
|
|
|
|
-- implicit-conversion-allowed 'zero' --}(SIZE (0..ub-bit-options))
|
|
|
|
OtherRecipientNames ::= SEQUENCE SIZE (1..ub-recipients) OF OtherRecipientName
|
|
|
|
OtherRecipientName ::= ORAddressAndOptionalDirectoryName
|
|
|
|
ThisRecipientName ::= ORAddressAndOptionalDirectoryName
|
|
|
|
OriginallyIntendedRecipientName ::= ORAddressAndOptionalDirectoryName
|
|
|
|
ConvertedEncodedInformationTypes ::= EncodedInformationTypes
|
|
|
|
SubjectSubmissionIdentifier ::= MTSIdentifier
|
|
|
|
ActualRecipientName ::= ORAddressAndOrDirectoryName
|
|
|
|
TypeOfMTSUser ::= INTEGER {
|
|
public(0), private(1), ms(2), dl(3), pdau(4), physical-recipient(5), other(6)
|
|
}(0..ub-mts-user-types)
|
|
|
|
NonDeliveryReasonCode ::= INTEGER {
|
|
transfer-failure(0), unable-to-transfer(1), conversion-not-performed(2),
|
|
physical-rendition-not-performed(3), physical-delivery-not-performed(4),
|
|
restricted-delivery(5), directory-operation-unsuccessful(6),
|
|
deferred-delivery-not-performed(7), transfer-failure-for-security-reason(8)
|
|
}(0..ub-reason-codes)
|
|
|
|
NonDeliveryDiagnosticCode ::= INTEGER {
|
|
unrecognised-OR-name(0), ambiguous-OR-name(1), mts-congestion(2),
|
|
loop-detected(3), recipient-unavailable(4), maximum-time-expired(5),
|
|
encoded-information-types-unsupported(6), content-too-long(7),
|
|
conversion-impractical(8), implicit-conversion-prohibited(9),
|
|
implicit-conversion-not-subscribed(10), invalid-arguments(11),
|
|
content-syntax-error(12), size-constraint-violation(13),
|
|
protocol-violation(14), content-type-not-supported(15),
|
|
too-many-recipients(16), no-bilateral-agreement(17),
|
|
unsupported-critical-function(18), conversion-with-loss-prohibited(19),
|
|
line-too-long(20), page-split(21), pictorial-symbol-loss(22),
|
|
punctuation-symbol-loss(23), alphabetic-character-loss(24),
|
|
multiple-information-loss(25), recipient-reassignment-prohibited(26),
|
|
redirection-loop-detected(27), dl-expansion-prohibited(28),
|
|
no-dl-submit-permission(29), dl-expansion-failure(30),
|
|
physical-rendition-attributes-not-supported(31),
|
|
undeliverable-mail-physical-delivery-address-incorrect(32),
|
|
undeliverable-mail-physical-delivery-office-incorrect-or-invalid(33),
|
|
undeliverable-mail-physical-delivery-address-incomplete(34),
|
|
undeliverable-mail-recipient-unknown(35),
|
|
undeliverable-mail-recipient-deceased(36),
|
|
undeliverable-mail-organization-expired(37),
|
|
undeliverable-mail-recipient-refused-to-accept(38),
|
|
undeliverable-mail-recipient-did-not-claim(39),
|
|
undeliverable-mail-recipient-changed-address-permanently(40),
|
|
undeliverable-mail-recipient-changed-address-temporarily(41),
|
|
undeliverable-mail-recipient-changed-temporary-address(42),
|
|
undeliverable-mail-new-address-unknown(43),
|
|
undeliverable-mail-recipient-did-not-want-forwarding(44),
|
|
undeliverable-mail-originator-prohibited-forwarding(45),
|
|
secure-messaging-error(46), unable-to-downgrade(47),
|
|
unable-to-complete-transfer(48), transfer-attempts-limit-reached(49),
|
|
incorrect-notification-type(50),
|
|
dl-expansion-prohibited-by-security-policy(51),
|
|
forbidden-alternate-recipient(52), security-policy-violation(53),
|
|
security-services-refusal(54), unauthorised-dl-member(55),
|
|
unauthorised-dl-name(56),
|
|
unauthorised-originally-intended-recipient-name(57),
|
|
unauthorised-originator-name(58), unauthorised-recipient-name(59),
|
|
unreliable-system(60), authentication-failure-on-subject-message(61),
|
|
decryption-failed(62), decryption-key-unobtainable(63),
|
|
double-envelope-creation-failure(64),
|
|
double-enveloping-message-restoring-failure(65),
|
|
failure-of-proof-of-message(66), integrity-failure-on-subject-message(67),
|
|
invalid-security-label(68), key-failure(69), mandatory-parameter-absence(70),
|
|
operation-security-failure(71), repudiation-failure-of-message(72),
|
|
security-context-failure(73), token-decryption-failed(74), token-error(75),
|
|
unknown-security-label(76), unsupported-algorithm-identifier(77),
|
|
unsupported-security-policy(78)}(0..ub-diagnostic-codes)
|
|
|
|
SupplementaryInformation ::=
|
|
PrintableString(SIZE (1..ub-supplementary-info-length))
|
|
|
|
-- Extension Fields
|
|
EXTENSION ::= CLASS {
|
|
&id ExtensionType UNIQUE,
|
|
&Type OPTIONAL,
|
|
&absent &Type OPTIONAL,
|
|
&recommended Criticality DEFAULT {}
|
|
}
|
|
WITH SYNTAX {
|
|
[&Type
|
|
[IF ABSENT &absent],]
|
|
[RECOMMENDED CRITICALITY &recommended,]
|
|
IDENTIFIED BY &id
|
|
}
|
|
|
|
ExtensionType ::= CHOICE {
|
|
standard-extension [0] --INTEGER(0..ub-extension-types)-- StandardExtension,
|
|
private-extension [3] OBJECT IDENTIFIER
|
|
}
|
|
|
|
StandardExtension ::= INTEGER {
|
|
recipient-reassignment-prohibited (1),
|
|
originator-requested-alternate-recipient (2),
|
|
dl-expansion-prohibited (3),
|
|
conversion-with-loss-prohibited (4),
|
|
latest-delivery-time (5),
|
|
requested-delivery-method (6),
|
|
physical-forwarding-prohibited (7),
|
|
physical-forwarding-address-request (8),
|
|
physical-delivery-modes (9),
|
|
registered-mail-type (10),
|
|
recipient-number-for-advice (11),
|
|
physical-rendition-attributes (12),
|
|
originator-return-address (13),
|
|
physical-delivery-report-request (14),
|
|
originator-certificate (15),
|
|
message-token (16),
|
|
content-confidentiality-algorithm-identifier (17),
|
|
content-integrity-check (18),
|
|
message-origin-authentication-check (19),
|
|
message-security-label (20),
|
|
proof-of-submission-request (21),
|
|
proof-of-delivery-request (22),
|
|
content-correlator (23),
|
|
probe-origin-authentication-check (24),
|
|
redirection-history (25),
|
|
dl-expansion-history (26),
|
|
physical-forwarding-address (27),
|
|
recipient-certificate (28),
|
|
proof-of-delivery (29),
|
|
originator-and-DL-expansion-history (30),
|
|
reporting-DL-name (31),
|
|
reporting-MTA-certificate (32),
|
|
report-origin-authentication-check (33),
|
|
originating-MTA-certificate (34),
|
|
proof-of-submission (35),
|
|
forwarding-request (36),
|
|
trace-information (37),
|
|
internal-trace-information (38),
|
|
reporting-MTA-name (39),
|
|
multiple-originator-certificates (40),
|
|
blind-copy-recipients (41),
|
|
dl-exempted-recipients (42),
|
|
body-part-encryption-token (43),
|
|
forwarded-content-token (44),
|
|
certificate-selectors (45)
|
|
}
|
|
|
|
|
|
Criticality ::= BIT STRING {for-submission(0), for-transfer(1), for-delivery(2)
|
|
}(SIZE (0..ub-bit-options)) -- critical 'one', non-critical 'zero'
|
|
|
|
|
|
ExtensionField{EXTENSION:ChosenFrom} ::= SEQUENCE {
|
|
type EXTENSION.&id({ChosenFrom}),
|
|
criticality [1] Criticality DEFAULT {},
|
|
value [2] EXTENSION.&Type({ChosenFrom}{@type}) DEFAULT NULL:NULL
|
|
}
|
|
|
|
PrivateExtensions EXTENSION ::=
|
|
{-- Any value shall be relayed and delivered if not Critical (see Table 27)
|
|
-- except those values whose semantics the MTA obeys which are defined to be removed when obeyed.
|
|
-- Shall be IDENTIFIED BY ExtensionType.private-extension --...}
|
|
|
|
recipient-reassignment-prohibited EXTENSION ::= {
|
|
RecipientReassignmentProhibited
|
|
IF ABSENT recipient-reassignment-allowed,
|
|
RECOMMENDED CRITICALITY {for-delivery},
|
|
IDENTIFIED BY standard-extension:1
|
|
}
|
|
|
|
RecipientReassignmentProhibited ::= ENUMERATED {
|
|
recipient-reassignment-allowed(0), recipient-reassignment-prohibited(1)
|
|
}
|
|
|
|
originator-requested-alternate-recipient EXTENSION ::= {
|
|
OriginatorRequestedAlternateRecipient,
|
|
RECOMMENDED CRITICALITY {for-submission},
|
|
IDENTIFIED BY standard-extension:2
|
|
}
|
|
|
|
OriginatorRequestedAlternateRecipient ::= ORAddressAndOrDirectoryName
|
|
|
|
-- OriginatorRequestedAlternateRecipient as defined here differs from the field of the same name
|
|
-- defined in Figure 4, since on submission the OR-address need not be present, but on
|
|
-- transfer the OR-address must be present.
|
|
dl-expansion-prohibited EXTENSION ::= {
|
|
DLExpansionProhibited
|
|
IF ABSENT dl-expansion-allowed,
|
|
RECOMMENDED CRITICALITY {for-delivery},
|
|
IDENTIFIED BY standard-extension:3
|
|
}
|
|
|
|
DLExpansionProhibited ::= ENUMERATED {
|
|
dl-expansion-allowed(0), dl-expansion-prohibited(1)}
|
|
|
|
conversion-with-loss-prohibited EXTENSION ::= {
|
|
ConversionWithLossProhibited
|
|
IF ABSENT conversion-with-loss-allowed,
|
|
RECOMMENDED CRITICALITY {for-delivery},
|
|
IDENTIFIED BY standard-extension:4
|
|
}
|
|
|
|
ConversionWithLossProhibited ::= ENUMERATED {
|
|
conversion-with-loss-allowed(0), conversion-with-loss-prohibited(1)
|
|
}
|
|
|
|
latest-delivery-time EXTENSION ::= {
|
|
LatestDeliveryTime,
|
|
RECOMMENDED CRITICALITY {for-delivery},
|
|
IDENTIFIED BY standard-extension:5
|
|
}
|
|
|
|
LatestDeliveryTime ::= Time
|
|
|
|
requested-delivery-method EXTENSION ::= {
|
|
RequestedDeliveryMethod
|
|
IF ABSENT {any-delivery-method},
|
|
IDENTIFIED BY standard-extension:6
|
|
}
|
|
|
|
RequestedDeliveryMethod ::=
|
|
SEQUENCE OF INTEGER { -- each different in order of preference,
|
|
-- most preferred first
|
|
any-delivery-method(0), mhs-delivery(1), physical-delivery(2),
|
|
telex-delivery(3), teletex-delivery(4), g3-facsimile-delivery(5),
|
|
g4-facsimile-delivery(6), ia5-terminal-delivery(7), videotex-delivery(8),
|
|
telephone-delivery(9)}(0..ub-integer-options)
|
|
|
|
physical-forwarding-prohibited EXTENSION ::= {
|
|
PhysicalForwardingProhibited
|
|
IF ABSENT physical-forwarding-allowed,
|
|
RECOMMENDED CRITICALITY {for-delivery},
|
|
IDENTIFIED BY standard-extension:7
|
|
}
|
|
|
|
PhysicalForwardingProhibited ::= ENUMERATED {
|
|
physical-forwarding-allowed(0), physical-forwarding-prohibited(1)}
|
|
|
|
physical-forwarding-address-request EXTENSION ::= {
|
|
PhysicalForwardingAddressRequest
|
|
IF ABSENT physical-forwarding-address-not-requested,
|
|
RECOMMENDED CRITICALITY {for-delivery},
|
|
IDENTIFIED BY standard-extension:8
|
|
}
|
|
|
|
PhysicalForwardingAddressRequest ::= ENUMERATED {
|
|
physical-forwarding-address-not-requested(0),
|
|
physical-forwarding-address-requested(1)}
|
|
|
|
physical-delivery-modes EXTENSION ::= {
|
|
PhysicalDeliveryModes
|
|
IF ABSENT {ordinary-mail},
|
|
RECOMMENDED CRITICALITY {for-delivery},
|
|
IDENTIFIED BY standard-extension:9
|
|
}
|
|
|
|
PhysicalDeliveryModes ::= BIT STRING {
|
|
ordinary-mail(0), special-delivery(1), express-mail(2),
|
|
counter-collection(3), counter-collection-with-telephone-advice(4),
|
|
counter-collection-with-telex-advice(5),
|
|
counter-collection-with-teletex-advice(6), bureau-fax-delivery(7)
|
|
|
|
-- bits 0 to 6 are mutually exclusive
|
|
-- bit 7 can be set independently of any of bits 0 to 6 --}
|
|
(SIZE (0..ub-bit-options))
|
|
|
|
registered-mail-type EXTENSION ::= {
|
|
RegisteredMailType
|
|
IF ABSENT non-registered-mail,
|
|
RECOMMENDED CRITICALITY {for-delivery},
|
|
IDENTIFIED BY standard-extension:10
|
|
}
|
|
|
|
RegisteredMailType ::= INTEGER {
|
|
non-registered-mail(0), registered-mail(1),
|
|
registered-mail-to-addressee-in-person(2)}(0..ub-integer-options)
|
|
|
|
recipient-number-for-advice EXTENSION ::= {
|
|
RecipientNumberForAdvice,
|
|
RECOMMENDED CRITICALITY {for-delivery},
|
|
IDENTIFIED BY standard-extension:11
|
|
}
|
|
|
|
RecipientNumberForAdvice ::=
|
|
TeletexString(SIZE (1..ub-recipient-number-for-advice-length))
|
|
|
|
physical-rendition-attributes EXTENSION ::= {
|
|
PhysicalRenditionAttributes
|
|
IF ABSENT id-att-physicalRendition-basic,
|
|
RECOMMENDED CRITICALITY {for-delivery},
|
|
IDENTIFIED BY standard-extension:12
|
|
}
|
|
|
|
PhysicalRenditionAttributes ::= OBJECT IDENTIFIER
|
|
|
|
originator-return-address EXTENSION ::= {
|
|
OriginatorReturnAddress,
|
|
IDENTIFIED BY standard-extension:13
|
|
}
|
|
|
|
OriginatorReturnAddress ::= ORAddress
|
|
|
|
physical-delivery-report-request EXTENSION ::= {
|
|
PhysicalDeliveryReportRequest
|
|
IF ABSENT return-of-undeliverable-mail-by-PDS,
|
|
RECOMMENDED CRITICALITY {for-delivery},
|
|
IDENTIFIED BY standard-extension:14
|
|
}
|
|
|
|
PhysicalDeliveryReportRequest ::= INTEGER {
|
|
return-of-undeliverable-mail-by-PDS(0), return-of-notification-by-PDS(1),
|
|
return-of-notification-by-MHS(2), return-of-notification-by-MHS-and-PDS(3)
|
|
}(0..ub-integer-options)
|
|
|
|
originator-certificate EXTENSION ::= {
|
|
OriginatorCertificate,
|
|
IDENTIFIED BY standard-extension:15
|
|
}
|
|
|
|
OriginatorCertificate ::= Certificates
|
|
|
|
message-token EXTENSION ::= {
|
|
MessageToken,
|
|
RECOMMENDED CRITICALITY {for-delivery},
|
|
IDENTIFIED BY standard-extension:16
|
|
}
|
|
|
|
MessageToken ::= Token
|
|
|
|
content-confidentiality-algorithm-identifier EXTENSION ::= {
|
|
ContentConfidentialityAlgorithmIdentifier,
|
|
RECOMMENDED CRITICALITY {for-delivery},
|
|
IDENTIFIED BY standard-extension:17
|
|
}
|
|
|
|
ContentConfidentialityAlgorithmIdentifier ::= AlgorithmIdentifier
|
|
|
|
content-integrity-check EXTENSION ::= {
|
|
ContentIntegrityCheck,
|
|
RECOMMENDED CRITICALITY {for-delivery},
|
|
IDENTIFIED BY standard-extension:18
|
|
}
|
|
|
|
ContentIntegrityCheck ::= Signature
|
|
-- SIGNATURE
|
|
-- {SEQUENCE {algorithm-identifier
|
|
-- ContentIntegrityAlgorithmIdentifier OPTIONAL,
|
|
-- content Content}}
|
|
|
|
ContentIntegrityAlgorithmIdentifier ::= AlgorithmIdentifier
|
|
|
|
message-origin-authentication-check EXTENSION ::= {
|
|
MessageOriginAuthenticationCheck,
|
|
RECOMMENDED CRITICALITY {for-delivery},
|
|
IDENTIFIED BY standard-extension:19
|
|
}
|
|
|
|
MessageOriginAuthenticationCheck ::= Signature
|
|
-- SIGNATURE
|
|
-- {SEQUENCE {algorithm-identifier
|
|
-- MessageOriginAuthenticationAlgorithmIdentifier,
|
|
-- content Content,
|
|
-- content-identifier ContentIdentifier OPTIONAL,
|
|
-- message-security-label MessageSecurityLabel OPTIONAL}}
|
|
|
|
MessageOriginAuthenticationAlgorithmIdentifier ::= AlgorithmIdentifier
|
|
|
|
message-security-label EXTENSION ::= {
|
|
MessageSecurityLabel,
|
|
RECOMMENDED CRITICALITY {for-delivery},
|
|
IDENTIFIED BY standard-extension:20
|
|
}
|
|
|
|
MessageSecurityLabel ::= SecurityLabel
|
|
|
|
proof-of-submission-request EXTENSION ::= {
|
|
ProofOfSubmissionRequest
|
|
IF ABSENT proof-of-submission-not-requested,
|
|
RECOMMENDED CRITICALITY {for-submission},
|
|
IDENTIFIED BY standard-extension:21
|
|
}
|
|
|
|
ProofOfSubmissionRequest ::= ENUMERATED {
|
|
proof-of-submission-not-requested(0), proof-of-submission-requested(1)
|
|
}
|
|
|
|
proof-of-delivery-request EXTENSION ::= {
|
|
ProofOfDeliveryRequest
|
|
IF ABSENT proof-of-delivery-not-requested,
|
|
RECOMMENDED CRITICALITY {for-delivery},
|
|
IDENTIFIED BY standard-extension:22
|
|
}
|
|
|
|
ProofOfDeliveryRequest ::= ENUMERATED {
|
|
proof-of-delivery-not-requested(0), proof-of-delivery-requested(1)}
|
|
|
|
content-correlator EXTENSION ::= {
|
|
ContentCorrelator,
|
|
IDENTIFIED BY standard-extension:23
|
|
}
|
|
|
|
ContentCorrelator ::= CHOICE {ia5text IA5String,
|
|
octets OCTET STRING
|
|
}
|
|
|
|
probe-origin-authentication-check EXTENSION ::= {
|
|
ProbeOriginAuthenticationCheck,
|
|
RECOMMENDED CRITICALITY {for-delivery},
|
|
IDENTIFIED BY standard-extension:24
|
|
}
|
|
|
|
ProbeOriginAuthenticationCheck ::= Signature
|
|
-- SIGNATURE
|
|
-- {SEQUENCE {algorithm-identifier
|
|
-- ProbeOriginAuthenticationAlgorithmIdentifier,
|
|
-- content-identifier ContentIdentifier OPTIONAL,
|
|
-- message-security-label MessageSecurityLabel OPTIONAL}}
|
|
|
|
ProbeOriginAuthenticationAlgorithmIdentifier ::= AlgorithmIdentifier
|
|
|
|
redirection-history EXTENSION ::= {
|
|
RedirectionHistory,
|
|
IDENTIFIED BY standard-extension:25
|
|
}
|
|
|
|
RedirectionHistory ::= SEQUENCE SIZE (1..ub-redirections) OF Redirection
|
|
|
|
Redirection ::= SEQUENCE {
|
|
intended-recipient-name IntendedRecipientName,
|
|
redirection-reason RedirectionReason
|
|
}
|
|
|
|
IntendedRecipientName ::= SEQUENCE {
|
|
intended-recipient ORAddressAndOptionalDirectoryName,
|
|
redirection-time Time
|
|
}
|
|
|
|
RedirectionReason ::= ENUMERATED {
|
|
recipient-assigned-alternate-recipient(0),
|
|
originator-requested-alternate-recipient(1),
|
|
recipient-MD-assigned-alternate-recipient(2),
|
|
-- The following values may not be supported by implementations of earlier versions of this Service Definition
|
|
directory-look-up(3), alias(4), ...
|
|
}
|
|
|
|
dl-expansion-history EXTENSION ::= {
|
|
DLExpansionHistory,
|
|
IDENTIFIED BY standard-extension:26
|
|
}
|
|
|
|
DLExpansionHistory ::= SEQUENCE SIZE (1..ub-dl-expansions) OF DLExpansion
|
|
|
|
DLExpansion ::= SEQUENCE {
|
|
dl ORAddressAndOptionalDirectoryName,
|
|
dl-expansion-time Time
|
|
}
|
|
|
|
physical-forwarding-address EXTENSION ::= {
|
|
PhysicalForwardingAddress,
|
|
IDENTIFIED BY standard-extension:27
|
|
}
|
|
|
|
PhysicalForwardingAddress ::= ORAddressAndOptionalDirectoryName
|
|
|
|
recipient-certificate EXTENSION ::= {
|
|
RecipientCertificate,
|
|
IDENTIFIED BY standard-extension:28
|
|
}
|
|
|
|
proof-of-delivery EXTENSION ::= {
|
|
ProofOfDelivery,
|
|
IDENTIFIED BY standard-extension:29
|
|
}
|
|
|
|
originator-and-DL-expansion-history EXTENSION ::= {
|
|
OriginatorAndDLExpansionHistory,
|
|
IDENTIFIED BY standard-extension:30
|
|
}
|
|
|
|
OriginatorAndDLExpansionHistory ::=
|
|
SEQUENCE SIZE (2..ub-orig-and-dl-expansions) OF OriginatorAndDLExpansion
|
|
|
|
OriginatorAndDLExpansion ::= SEQUENCE {
|
|
originator-or-dl-name ORAddressAndOptionalDirectoryName,
|
|
origination-or-expansion-time Time
|
|
}
|
|
|
|
reporting-DL-name EXTENSION ::= {
|
|
ReportingDLName,
|
|
IDENTIFIED BY standard-extension:31
|
|
}
|
|
|
|
ReportingDLName ::= ORAddressAndOptionalDirectoryName
|
|
|
|
reporting-MTA-certificate EXTENSION ::= {
|
|
ReportingMTACertificate,
|
|
RECOMMENDED CRITICALITY {for-delivery},
|
|
IDENTIFIED BY standard-extension:32
|
|
}
|
|
|
|
ReportingMTACertificate ::= Certificates
|
|
|
|
report-origin-authentication-check EXTENSION ::= {
|
|
ReportOriginAuthenticationCheck,
|
|
RECOMMENDED CRITICALITY {for-delivery},
|
|
IDENTIFIED BY standard-extension:33
|
|
}
|
|
|
|
ReportOriginAuthenticationCheck ::= Signature
|
|
-- SIGNATURE
|
|
-- {SEQUENCE {algorithm-identifier
|
|
-- ReportOriginAuthenticationAlgorithmIdentifier,
|
|
-- content-identifier ContentIdentifier OPTIONAL,
|
|
-- message-security-label MessageSecurityLabel OPTIONAL,
|
|
-- per-recipient
|
|
-- SEQUENCE SIZE (1..ub-recipients) OF PerRecipientReportFields
|
|
-- }}
|
|
|
|
ReportOriginAuthenticationAlgorithmIdentifier ::= AlgorithmIdentifier
|
|
|
|
PerRecipientReportFields ::= SEQUENCE {
|
|
actual-recipient-name ActualRecipientName,
|
|
originally-intended-recipient-name OriginallyIntendedRecipientName OPTIONAL,
|
|
report-type
|
|
CHOICE {delivery [0] PerRecipientDeliveryReportFields,
|
|
non-delivery [1] PerRecipientNonDeliveryReportFields}
|
|
}
|
|
|
|
PerRecipientDeliveryReportFields ::= SEQUENCE {
|
|
message-delivery-time MessageDeliveryTime,
|
|
type-of-MTS-user TypeOfMTSUser,
|
|
recipient-certificate [0] RecipientCertificate OPTIONAL,
|
|
proof-of-delivery [1] ProofOfDelivery OPTIONAL
|
|
}
|
|
|
|
PerRecipientNonDeliveryReportFields ::= SEQUENCE {
|
|
non-delivery-reason-code NonDeliveryReasonCode,
|
|
non-delivery-diagnostic-code NonDeliveryDiagnosticCode OPTIONAL
|
|
}
|
|
|
|
originating-MTA-certificate EXTENSION ::= {
|
|
OriginatingMTACertificate,
|
|
IDENTIFIED BY standard-extension:34
|
|
}
|
|
|
|
OriginatingMTACertificate ::= Certificates
|
|
|
|
proof-of-submission EXTENSION ::= {
|
|
ProofOfSubmission,
|
|
IDENTIFIED BY standard-extension:35
|
|
}
|
|
|
|
ProofOfSubmission ::= Signature
|
|
-- SIGNATURE
|
|
-- {SEQUENCE {algorithm-identifier
|
|
-- ProofOfSubmissionAlgorithmIdentifier,
|
|
-- message-submission-envelope MessageSubmissionEnvelope,
|
|
-- content Content,
|
|
-- message-submission-identifier MessageSubmissionIdentifier,
|
|
-- message-submission-time MessageSubmissionTime}}
|
|
|
|
ProofOfSubmissionAlgorithmIdentifier ::= AlgorithmIdentifier
|
|
|
|
reporting-MTA-name EXTENSION ::= {
|
|
ReportingMTAName,
|
|
IDENTIFIED BY standard-extension:39
|
|
}
|
|
|
|
ReportingMTAName ::= SEQUENCE {
|
|
domain GlobalDomainIdentifier,
|
|
mta-name MTAName,
|
|
mta-directory-name [0] Name OPTIONAL
|
|
}
|
|
|
|
multiple-originator-certificates EXTENSION ::= {
|
|
ExtendedCertificates,
|
|
IDENTIFIED BY standard-extension:40
|
|
}
|
|
|
|
ExtendedCertificates ::= SET SIZE (1..ub-certificates) OF ExtendedCertificate
|
|
|
|
ExtendedCertificate ::= CHOICE {
|
|
directory-entry [0] Name, -- Name of a Directory entry where the certificate can be found
|
|
certificate [1] Certificates
|
|
}
|
|
|
|
dl-exempted-recipients EXTENSION ::= {
|
|
DLExemptedRecipients,
|
|
IDENTIFIED BY standard-extension:42
|
|
}
|
|
|
|
DLExemptedRecipients ::= SET OF ORAddressAndOrDirectoryName
|
|
|
|
certificate-selectors EXTENSION ::= {
|
|
CertificateSelectors,
|
|
IDENTIFIED BY standard-extension:45
|
|
}
|
|
|
|
CertificateSelectors ::= SET {
|
|
encryption-recipient [0] CertificateAssertion OPTIONAL,
|
|
encryption-originator [1] CertificateAssertion OPTIONAL,
|
|
content-integrity-check [2] CertificateAssertion OPTIONAL,
|
|
token-signature [3] CertificateAssertion OPTIONAL,
|
|
message-origin-authentication [4] CertificateAssertion OPTIONAL
|
|
}
|
|
|
|
certificate-selectors-override EXTENSION ::= {
|
|
CertificateSelectors
|
|
(WITH COMPONENTS {
|
|
...,
|
|
message-origin-authentication ABSENT
|
|
}),
|
|
IDENTIFIED BY standard-extension:46
|
|
}
|
|
|
|
-- Some standard-extensions are defined elsewhere:
|
|
-- 36 (forwarding-request) in ITU-T Rec. X.413 | ISO/IEC 10021-5;
|
|
-- 37 (trace-information), and 38 (internal-trace-information) in Figure 4;
|
|
-- 41 (blind-copy-recipients), 43 (body-part-encryption-token), and 44 (forwarded-content-token) in
|
|
-- ITU-T Rec. X.420 | ISO/IEC 10021-7
|
|
-- Common Parameter Types
|
|
Content ::=
|
|
OCTET
|
|
STRING -- when the content-type has the integer value external, the value of the
|
|
|
|
-- content octet string is the ASN.1 encoding of the external-content;
|
|
-- an external-content is a data type EXTERNAL
|
|
MTSIdentifier ::= [APPLICATION 4] SEQUENCE {
|
|
global-domain-identifier GlobalDomainIdentifier,
|
|
local-identifier LocalIdentifier
|
|
}
|
|
|
|
LocalIdentifier ::= IA5String(SIZE (1..ub-local-id-length))
|
|
|
|
GlobalDomainIdentifier ::= [APPLICATION 3] SEQUENCE {
|
|
country-name CountryName,
|
|
administration-domain-name AdministrationDomainName,
|
|
private-domain-identifier PrivateDomainIdentifier OPTIONAL
|
|
}
|
|
|
|
PrivateDomainIdentifier ::= CHOICE {
|
|
numeric NumericString(SIZE (1..ub-domain-name-length)),
|
|
printable PrintableString(SIZE (1..ub-domain-name-length))
|
|
}
|
|
|
|
MTAName ::= IA5String(SIZE (1..ub-mta-name-length))
|
|
|
|
Time ::= UTCTime
|
|
|
|
-- OR Names
|
|
ORAddressAndOrDirectoryName ::= ORName
|
|
|
|
ORAddressAndOptionalDirectoryName ::= ORName
|
|
|
|
ORName ::= [APPLICATION 0] SEQUENCE {
|
|
-- address --COMPONENTS OF ORAddress,
|
|
directory-name [0] Name OPTIONAL
|
|
}
|
|
|
|
ORAddress ::= SEQUENCE {
|
|
built-in-standard-attributes BuiltInStandardAttributes,
|
|
built-in-domain-defined-attributes BuiltInDomainDefinedAttributes OPTIONAL,
|
|
-- see also teletex-domain-defined-attributes
|
|
extension-attributes ExtensionAttributes OPTIONAL
|
|
}
|
|
|
|
-- The OR-address is semantically absent from the OR-name if the built-in-standard-attribute
|
|
-- sequence is empty and the built-in-domain-defined-attributes and extension-attributes are both omitted.
|
|
-- Built-in Standard Attributes
|
|
BuiltInStandardAttributes ::= SEQUENCE {
|
|
country-name CountryName OPTIONAL,
|
|
administration-domain-name AdministrationDomainName OPTIONAL,
|
|
network-address [0] NetworkAddress OPTIONAL,
|
|
-- see also extended-network-address
|
|
terminal-identifier [1] TerminalIdentifier OPTIONAL,
|
|
private-domain-name [2] PrivateDomainName OPTIONAL,
|
|
organization-name [3] OrganizationName OPTIONAL,
|
|
-- see also teletex-organization-name
|
|
numeric-user-identifier [4] NumericUserIdentifier OPTIONAL,
|
|
personal-name [5] PersonalName OPTIONAL,
|
|
-- see also teletex-personal-name
|
|
organizational-unit-names [6] OrganizationalUnitNames OPTIONAL
|
|
-- see also teletex-organizational-unit-names
|
|
}
|
|
|
|
CountryName ::= [APPLICATION 1] CHOICE {
|
|
x121-dcc-code NumericString(SIZE (ub-country-name-numeric-length)),
|
|
iso-3166-alpha2-code PrintableString(SIZE (ub-country-name-alpha-length))
|
|
}
|
|
|
|
AdministrationDomainName ::= [APPLICATION 2] CHOICE {
|
|
numeric NumericString(SIZE (0..ub-domain-name-length)),
|
|
printable PrintableString(SIZE (0..ub-domain-name-length))
|
|
}
|
|
|
|
NetworkAddress ::= X121Address
|
|
|
|
-- see also extended-network-address
|
|
X121Address ::= NumericString(SIZE (1..ub-x121-address-length))
|
|
|
|
TerminalIdentifier ::= PrintableString(SIZE (1..ub-terminal-id-length))
|
|
|
|
PrivateDomainName ::= CHOICE {
|
|
numeric NumericString(SIZE (1..ub-domain-name-length)),
|
|
printable PrintableString(SIZE (1..ub-domain-name-length))
|
|
}
|
|
|
|
OrganizationName ::= PrintableString(SIZE (1..ub-organization-name-length))
|
|
|
|
-- see also teletex-organization-name
|
|
NumericUserIdentifier ::= NumericString(SIZE (1..ub-numeric-user-id-length))
|
|
|
|
PersonalName ::= SET {
|
|
surname [0] PrintableString(SIZE (1..ub-surname-length)),
|
|
given-name
|
|
[1] PrintableString(SIZE (1..ub-given-name-length)) OPTIONAL,
|
|
initials
|
|
[2] PrintableString(SIZE (1..ub-initials-length)) OPTIONAL,
|
|
generation-qualifier
|
|
[3] PrintableString(SIZE (1..ub-generation-qualifier-length)) OPTIONAL
|
|
}
|
|
|
|
-- see also teletex-personal-name
|
|
OrganizationalUnitNames ::=
|
|
SEQUENCE SIZE (1..ub-organizational-units) OF OrganizationalUnitName
|
|
|
|
-- see also teletex-organizational-unit-names
|
|
OrganizationalUnitName ::=
|
|
PrintableString(SIZE (1..ub-organizational-unit-name-length))
|
|
|
|
-- Built-in Domain-defined Attributes
|
|
BuiltInDomainDefinedAttributes ::=
|
|
SEQUENCE SIZE (1..ub-domain-defined-attributes) OF
|
|
BuiltInDomainDefinedAttribute
|
|
|
|
BuiltInDomainDefinedAttribute ::= SEQUENCE {
|
|
type PrintableString(SIZE (1..ub-domain-defined-attribute-type-length)),
|
|
value PrintableString(SIZE (1..ub-domain-defined-attribute-value-length))
|
|
}
|
|
|
|
-- Extension Attributes
|
|
ExtensionAttributes ::=
|
|
SET SIZE (1..ub-extension-attributes) OF ExtensionAttribute
|
|
|
|
ExtensionAttribute ::= SEQUENCE {
|
|
extension-attribute-type
|
|
[0] --EXTENSION-ATTRIBUTE.&id({ExtensionAttributeTable})-- ExtensionAttributeType,
|
|
extension-attribute-value
|
|
[1] EXTENSION-ATTRIBUTE.&Type
|
|
({ExtensionAttributeTable}{@extension-attribute-type})
|
|
}
|
|
|
|
ExtensionAttributeType ::= INTEGER {
|
|
common-name (1),
|
|
teletex-common-name (2),
|
|
teletex-organization-name (3),
|
|
teletex-personal-name (4),
|
|
teletex-organizational-unit-names (5),
|
|
teletex-domain-defined-attributes (6),
|
|
pds-name (7),
|
|
physical-delivery-country-name (8),
|
|
postal-code (9),
|
|
physical-delivery-office-name (10),
|
|
physical-delivery-office-number (11),
|
|
extension-OR-address-components (12),
|
|
physical-delivery-personal-name (13),
|
|
physical-delivery-organization-name (14),
|
|
extension-physical-delivery-address-components (15),
|
|
unformatted-postal-address (16),
|
|
street-address (17),
|
|
post-office-box-address (18),
|
|
poste-restante-address (19),
|
|
unique-postal-name (20),
|
|
local-postal-attributes (21),
|
|
extended-network-address (22),
|
|
terminal-type (23),
|
|
universal-common-name (24),
|
|
universal-organization-name (25),
|
|
universal-personal-name (26),
|
|
universal-organizational-unit-names (27),
|
|
universal-domain-defined-attributes (28),
|
|
universal-physical-delivery-office-name (29),
|
|
universal-physical-delivery-office-number (30),
|
|
universal-extension-OR-address-components (31),
|
|
universal-physical-delivery-personal-name (32),
|
|
universal-physical-delivery-organization-name (33),
|
|
universal-extension-physical-delivery-address-components (34),
|
|
universal-unformatted-postal-address (35),
|
|
universal-street-address (36),
|
|
universal-post-office-box-address (37),
|
|
universal-poste-restante-address (38),
|
|
universal-unique-postal-name (39),
|
|
universal-local-postal-attributes (40)
|
|
}
|
|
|
|
EXTENSION-ATTRIBUTE ::= CLASS {
|
|
&id INTEGER(0..ub-extension-attributes) UNIQUE,
|
|
&Type
|
|
}WITH SYNTAX {&Type
|
|
IDENTIFIED BY &id
|
|
}
|
|
|
|
ExtensionAttributeTable EXTENSION-ATTRIBUTE ::=
|
|
{common-name | teletex-common-name | universal-common-name |
|
|
teletex-organization-name | universal-organization-name |
|
|
teletex-personal-name | universal-personal-name |
|
|
teletex-organizational-unit-names | universal-organizational-unit-names |
|
|
teletex-domain-defined-attributes | universal-domain-defined-attributes |
|
|
pds-name | physical-delivery-country-name | postal-code |
|
|
physical-delivery-office-name | universal-physical-delivery-office-name |
|
|
physical-delivery-office-number | universal-physical-delivery-office-number
|
|
| extension-OR-address-components |
|
|
universal-extension-OR-address-components | physical-delivery-personal-name
|
|
| universal-physical-delivery-personal-name |
|
|
physical-delivery-organization-name |
|
|
universal-physical-delivery-organization-name |
|
|
extension-physical-delivery-address-components |
|
|
universal-extension-physical-delivery-address-components |
|
|
unformatted-postal-address | universal-unformatted-postal-address |
|
|
street-address | universal-street-address | post-office-box-address |
|
|
universal-post-office-box-address | poste-restante-address |
|
|
universal-poste-restante-address | unique-postal-name |
|
|
universal-unique-postal-name | local-postal-attributes |
|
|
universal-local-postal-attributes | extended-network-address | terminal-type
|
|
}
|
|
|
|
-- Extension Standard Attributes
|
|
common-name EXTENSION-ATTRIBUTE ::= {CommonName
|
|
IDENTIFIED BY 1
|
|
}
|
|
|
|
CommonName ::= PrintableString(SIZE (1..ub-common-name-length))
|
|
|
|
teletex-common-name EXTENSION-ATTRIBUTE ::= {TeletexCommonName
|
|
IDENTIFIED BY 2
|
|
}
|
|
|
|
TeletexCommonName ::= TeletexString(SIZE (1..ub-common-name-length))
|
|
|
|
universal-common-name EXTENSION-ATTRIBUTE ::= {
|
|
UniversalCommonName
|
|
IDENTIFIED BY 24
|
|
}
|
|
|
|
UniversalCommonName ::= UniversalOrBMPString{ub-common-name-length}
|
|
|
|
teletex-organization-name EXTENSION-ATTRIBUTE ::= {
|
|
TeletexOrganizationName
|
|
IDENTIFIED BY 3
|
|
}
|
|
|
|
TeletexOrganizationName ::=
|
|
TeletexString(SIZE (1..ub-organization-name-length))
|
|
|
|
universal-organization-name EXTENSION-ATTRIBUTE ::= {
|
|
UniversalOrganizationName
|
|
IDENTIFIED BY 25
|
|
}
|
|
|
|
UniversalOrganizationName ::= UniversalOrBMPString{ub-organization-name-length}
|
|
|
|
teletex-personal-name EXTENSION-ATTRIBUTE ::= {
|
|
TeletexPersonalName
|
|
IDENTIFIED BY 4
|
|
}
|
|
|
|
TeletexPersonalName ::= SET {
|
|
surname [0] TeletexString(SIZE (1..ub-surname-length)),
|
|
given-name
|
|
[1] TeletexString(SIZE (1..ub-given-name-length)) OPTIONAL,
|
|
initials
|
|
[2] TeletexString(SIZE (1..ub-initials-length)) OPTIONAL,
|
|
generation-qualifier
|
|
[3] TeletexString(SIZE (1..ub-generation-qualifier-length)) OPTIONAL
|
|
}
|
|
|
|
universal-personal-name EXTENSION-ATTRIBUTE ::= {
|
|
UniversalPersonalName
|
|
IDENTIFIED BY 26
|
|
}
|
|
|
|
UniversalPersonalName ::= SET {
|
|
surname [0] UniversalOrBMPString{ub-universal-surname-length},
|
|
-- If a language is specified within surname, then that language applies to each of the following
|
|
-- optional components unless the component specifies another language.
|
|
given-name
|
|
[1] UniversalOrBMPString{ub-universal-given-name-length} OPTIONAL,
|
|
initials
|
|
[2] UniversalOrBMPString{ub-universal-initials-length} OPTIONAL,
|
|
generation-qualifier
|
|
[3] UniversalOrBMPString{ub-universal-generation-qualifier-length}
|
|
OPTIONAL
|
|
}
|
|
|
|
teletex-organizational-unit-names EXTENSION-ATTRIBUTE ::= {
|
|
TeletexOrganizationalUnitNames
|
|
IDENTIFIED BY 5
|
|
}
|
|
|
|
TeletexOrganizationalUnitNames ::=
|
|
SEQUENCE SIZE (1..ub-organizational-units) OF TeletexOrganizationalUnitName
|
|
|
|
TeletexOrganizationalUnitName ::=
|
|
TeletexString(SIZE (1..ub-organizational-unit-name-length))
|
|
|
|
universal-organizational-unit-names EXTENSION-ATTRIBUTE ::= {
|
|
UniversalOrganizationalUnitNames
|
|
IDENTIFIED BY 27
|
|
}
|
|
|
|
UniversalOrganizationalUnitNames ::=
|
|
SEQUENCE SIZE (1..ub-organizational-units) OF UniversalOrganizationalUnitName
|
|
|
|
-- If a unit name specifies a language, then that language applies to subordinate unit names unless
|
|
-- the subordinate specifies another language.
|
|
UniversalOrganizationalUnitName ::=
|
|
UniversalOrBMPString{ub-organizational-unit-name-length}
|
|
|
|
UniversalOrBMPString{INTEGER:ub-string-length} ::= SET {
|
|
character-encoding
|
|
CHOICE {two-octets BMPString(SIZE (1..ub-string-length)),
|
|
four-octets UniversalString(SIZE (1..ub-string-length))},
|
|
iso-639-language-code PrintableString(SIZE (2 | 5)) OPTIONAL
|
|
}
|
|
|
|
pds-name EXTENSION-ATTRIBUTE ::= {PDSName
|
|
IDENTIFIED BY 7
|
|
}
|
|
|
|
PDSName ::= PrintableString(SIZE (1..ub-pds-name-length))
|
|
|
|
physical-delivery-country-name EXTENSION-ATTRIBUTE ::= {
|
|
PhysicalDeliveryCountryName
|
|
IDENTIFIED BY 8
|
|
}
|
|
|
|
PhysicalDeliveryCountryName ::= CHOICE {
|
|
x121-dcc-code NumericString(SIZE (ub-country-name-numeric-length)),
|
|
iso-3166-alpha2-code PrintableString(SIZE (ub-country-name-alpha-length))
|
|
}
|
|
|
|
postal-code EXTENSION-ATTRIBUTE ::= {PostalCode
|
|
IDENTIFIED BY 9
|
|
}
|
|
|
|
PostalCode ::= CHOICE {
|
|
numeric-code NumericString(SIZE (1..ub-postal-code-length)),
|
|
printable-code PrintableString(SIZE (1..ub-postal-code-length))
|
|
}
|
|
|
|
physical-delivery-office-name EXTENSION-ATTRIBUTE ::= {
|
|
PhysicalDeliveryOfficeName
|
|
IDENTIFIED BY 10
|
|
}
|
|
|
|
PhysicalDeliveryOfficeName ::= PDSParameter
|
|
|
|
universal-physical-delivery-office-name EXTENSION-ATTRIBUTE ::= {
|
|
UniversalPhysicalDeliveryOfficeName
|
|
IDENTIFIED BY 29
|
|
}
|
|
|
|
UniversalPhysicalDeliveryOfficeName ::= UniversalPDSParameter
|
|
|
|
physical-delivery-office-number EXTENSION-ATTRIBUTE ::= {
|
|
PhysicalDeliveryOfficeNumber
|
|
IDENTIFIED BY 11
|
|
}
|
|
|
|
PhysicalDeliveryOfficeNumber ::= PDSParameter
|
|
|
|
universal-physical-delivery-office-number EXTENSION-ATTRIBUTE ::= {
|
|
UniversalPhysicalDeliveryOfficeNumber
|
|
IDENTIFIED BY 30
|
|
}
|
|
|
|
UniversalPhysicalDeliveryOfficeNumber ::= UniversalPDSParameter
|
|
|
|
extension-OR-address-components EXTENSION-ATTRIBUTE ::= {
|
|
ExtensionORAddressComponents
|
|
IDENTIFIED BY 12
|
|
}
|
|
|
|
ExtensionORAddressComponents ::= PDSParameter
|
|
|
|
universal-extension-OR-address-components EXTENSION-ATTRIBUTE ::= {
|
|
UniversalExtensionORAddressComponents
|
|
IDENTIFIED BY 31
|
|
}
|
|
|
|
UniversalExtensionORAddressComponents ::= UniversalPDSParameter
|
|
|
|
physical-delivery-personal-name EXTENSION-ATTRIBUTE ::= {
|
|
PhysicalDeliveryPersonalName
|
|
IDENTIFIED BY 13
|
|
}
|
|
|
|
PhysicalDeliveryPersonalName ::= PDSParameter
|
|
|
|
universal-physical-delivery-personal-name EXTENSION-ATTRIBUTE ::= {
|
|
UniversalPhysicalDeliveryPersonalName
|
|
IDENTIFIED BY 32
|
|
}
|
|
|
|
UniversalPhysicalDeliveryPersonalName ::= UniversalPDSParameter
|
|
|
|
physical-delivery-organization-name EXTENSION-ATTRIBUTE ::= {
|
|
PhysicalDeliveryOrganizationName
|
|
IDENTIFIED BY 14
|
|
}
|
|
|
|
PhysicalDeliveryOrganizationName ::= PDSParameter
|
|
|
|
universal-physical-delivery-organization-name EXTENSION-ATTRIBUTE ::=
|
|
{UniversalPhysicalDeliveryOrganizationName
|
|
IDENTIFIED BY 33
|
|
}
|
|
|
|
UniversalPhysicalDeliveryOrganizationName ::= UniversalPDSParameter
|
|
|
|
extension-physical-delivery-address-components EXTENSION-ATTRIBUTE ::=
|
|
{ExtensionPhysicalDeliveryAddressComponents
|
|
IDENTIFIED BY 15
|
|
}
|
|
|
|
ExtensionPhysicalDeliveryAddressComponents ::= PDSParameter
|
|
|
|
universal-extension-physical-delivery-address-components EXTENSION-ATTRIBUTE
|
|
::= {UniversalExtensionPhysicalDeliveryAddressComponents
|
|
IDENTIFIED BY 34
|
|
}
|
|
|
|
UniversalExtensionPhysicalDeliveryAddressComponents ::= UniversalPDSParameter
|
|
|
|
unformatted-postal-address EXTENSION-ATTRIBUTE ::= {
|
|
UnformattedPostalAddress
|
|
IDENTIFIED BY 16
|
|
}
|
|
|
|
UnformattedPostalAddress ::= SET {
|
|
printable-address
|
|
SEQUENCE SIZE (1..ub-pds-physical-address-lines) OF
|
|
PrintableString(SIZE (1..ub-pds-parameter-length)) OPTIONAL,
|
|
teletex-string
|
|
TeletexString(SIZE (1..ub-unformatted-address-length)) OPTIONAL
|
|
}
|
|
|
|
universal-unformatted-postal-address EXTENSION-ATTRIBUTE ::= {
|
|
UniversalUnformattedPostalAddress
|
|
IDENTIFIED BY 35
|
|
}
|
|
|
|
UniversalUnformattedPostalAddress ::=
|
|
UniversalOrBMPString{ub-unformatted-address-length}
|
|
|
|
street-address EXTENSION-ATTRIBUTE ::= {StreetAddress
|
|
IDENTIFIED BY 17
|
|
}
|
|
|
|
StreetAddress ::= PDSParameter
|
|
|
|
universal-street-address EXTENSION-ATTRIBUTE ::= {
|
|
UniversalStreetAddress
|
|
IDENTIFIED BY 36
|
|
}
|
|
|
|
UniversalStreetAddress ::= UniversalPDSParameter
|
|
|
|
post-office-box-address EXTENSION-ATTRIBUTE ::= {
|
|
PostOfficeBoxAddress
|
|
IDENTIFIED BY 18
|
|
}
|
|
|
|
PostOfficeBoxAddress ::= PDSParameter
|
|
|
|
universal-post-office-box-address EXTENSION-ATTRIBUTE ::= {
|
|
UniversalPostOfficeBoxAddress
|
|
IDENTIFIED BY 37
|
|
}
|
|
|
|
UniversalPostOfficeBoxAddress ::= UniversalPDSParameter
|
|
|
|
poste-restante-address EXTENSION-ATTRIBUTE ::= {
|
|
PosteRestanteAddress
|
|
IDENTIFIED BY 19
|
|
}
|
|
|
|
PosteRestanteAddress ::= PDSParameter
|
|
|
|
universal-poste-restante-address EXTENSION-ATTRIBUTE ::= {
|
|
UniversalPosteRestanteAddress
|
|
IDENTIFIED BY 38
|
|
}
|
|
|
|
UniversalPosteRestanteAddress ::= UniversalPDSParameter
|
|
|
|
unique-postal-name EXTENSION-ATTRIBUTE ::= {UniquePostalName
|
|
IDENTIFIED BY 20
|
|
}
|
|
|
|
UniquePostalName ::= PDSParameter
|
|
|
|
universal-unique-postal-name EXTENSION-ATTRIBUTE ::= {
|
|
UniversalUniquePostalName
|
|
IDENTIFIED BY 39
|
|
}
|
|
|
|
UniversalUniquePostalName ::= UniversalPDSParameter
|
|
|
|
local-postal-attributes EXTENSION-ATTRIBUTE ::= {
|
|
LocalPostalAttributes
|
|
IDENTIFIED BY 21
|
|
}
|
|
|
|
LocalPostalAttributes ::= PDSParameter
|
|
|
|
universal-local-postal-attributes EXTENSION-ATTRIBUTE ::= {
|
|
UniversalLocalPostalAttributes
|
|
IDENTIFIED BY 40
|
|
}
|
|
|
|
UniversalLocalPostalAttributes ::= UniversalPDSParameter
|
|
|
|
PDSParameter ::= SET {
|
|
printable-string PrintableString(SIZE (1..ub-pds-parameter-length)) OPTIONAL,
|
|
teletex-string TeletexString(SIZE (1..ub-pds-parameter-length)) OPTIONAL
|
|
}
|
|
|
|
UniversalPDSParameter ::= UniversalOrBMPString{ub-pds-parameter-length}
|
|
|
|
extended-network-address EXTENSION-ATTRIBUTE ::= {
|
|
ExtendedNetworkAddress
|
|
IDENTIFIED BY 22
|
|
}
|
|
|
|
ExtendedNetworkAddress ::= CHOICE {
|
|
e163-4-address
|
|
SEQUENCE {number
|
|
[0] NumericString(SIZE (1..ub-e163-4-number-length)),
|
|
sub-address
|
|
[1] NumericString(SIZE (1..ub-e163-4-sub-address-length))
|
|
OPTIONAL},
|
|
psap-address [0] PresentationAddress
|
|
}
|
|
|
|
terminal-type EXTENSION-ATTRIBUTE ::= {TerminalType
|
|
IDENTIFIED BY 23
|
|
}
|
|
|
|
TerminalType ::= INTEGER {
|
|
telex(3), teletex(4), g3-facsimile(5), g4-facsimile(6), ia5-terminal(7),
|
|
videotex(8)}(0..ub-integer-options)
|
|
|
|
-- Extension Domain-defined Attributes
|
|
teletex-domain-defined-attributes EXTENSION-ATTRIBUTE ::= {
|
|
TeletexDomainDefinedAttributes
|
|
IDENTIFIED BY 6
|
|
}
|
|
|
|
TeletexDomainDefinedAttributes ::=
|
|
SEQUENCE SIZE (1..ub-domain-defined-attributes) OF
|
|
TeletexDomainDefinedAttribute
|
|
|
|
TeletexDomainDefinedAttribute ::= SEQUENCE {
|
|
type TeletexString(SIZE (1..ub-domain-defined-attribute-type-length)),
|
|
value TeletexString(SIZE (1..ub-domain-defined-attribute-value-length))
|
|
}
|
|
|
|
universal-domain-defined-attributes EXTENSION-ATTRIBUTE ::= {
|
|
UniversalDomainDefinedAttributes
|
|
IDENTIFIED BY 28
|
|
}
|
|
|
|
UniversalDomainDefinedAttributes ::=
|
|
SEQUENCE SIZE (1..ub-domain-defined-attributes) OF
|
|
UniversalDomainDefinedAttribute
|
|
|
|
UniversalDomainDefinedAttribute ::= SEQUENCE {
|
|
type UniversalOrBMPString{ub-domain-defined-attribute-type-length},
|
|
value UniversalOrBMPString{ub-domain-defined-attribute-value-length}
|
|
}
|
|
|
|
-- Encoded Information Types
|
|
EncodedInformationTypes ::= [APPLICATION 5] SET {
|
|
built-in-encoded-information-types [0] BuiltInEncodedInformationTypes,
|
|
-- non-basic-parameters --COMPONENTS OF NonBasicParameters,
|
|
extended-encoded-information-types
|
|
[4] ExtendedEncodedInformationTypes OPTIONAL
|
|
}
|
|
|
|
-- Built-in Encoded Information Types
|
|
BuiltInEncodedInformationTypes ::= BIT STRING {
|
|
unknown(0), ia5-text(2), g3-facsimile(3), g4-class-1(4), teletex(5),
|
|
videotex(6), voice(7), sfd(8), mixed-mode(9)
|
|
}(SIZE (0..ub-built-in-encoded-information-types))
|
|
|
|
-- Extended Encoded Information Types
|
|
ExtendedEncodedInformationTypes ::=
|
|
SET SIZE (1..ub-encoded-information-types) OF ExtendedEncodedInformationType
|
|
|
|
ExtendedEncodedInformationType ::= OBJECT IDENTIFIER
|
|
|
|
-- Non-basic Parameters
|
|
NonBasicParameters ::= SET {
|
|
g3-facsimile [1] G3FacsimileNonBasicParameters DEFAULT {},
|
|
teletex [2] TeletexNonBasicParameters DEFAULT {}
|
|
}
|
|
|
|
G3FacsimileNonBasicParameters ::= BIT STRING {
|
|
two-dimensional(8), -- As defined in ITU-T Recommendation T.30
|
|
fine-resolution(9), --
|
|
unlimited-length(20), -- These bit values are chosen such that when
|
|
b4-length(21), -- encoded using ASN.1 Basic Encoding Rules
|
|
a3-width(22), -- the resulting octets have the same values
|
|
b4-width(23), -- as for T.30 encoding
|
|
t6-coding(25), --
|
|
uncompressed(30), -- Trailing zero bits are not significant.
|
|
width-middle-864-of-1728(37), -- It is recommended that implementations
|
|
width-middle-1216-of-1728(38), -- should not encode more than 32 bits unless
|
|
resolution-type(44), -- higher numbered bits are non-zero.
|
|
resolution-400x400(45), resolution-300x300(46), resolution-8x15(47),
|
|
edi(49), dtm(50), bft(51), mixed-mode(58), character-mode(60),
|
|
twelve-bits(65), preferred-huffmann(66), full-colour(67), jpeg(68),
|
|
processable-mode-26(71)}
|
|
|
|
TeletexNonBasicParameters ::= SET {
|
|
graphic-character-sets [0] TeletexString OPTIONAL,
|
|
control-character-sets [1] TeletexString OPTIONAL,
|
|
page-formats [2] OCTET STRING OPTIONAL,
|
|
miscellaneous-terminal-capabilities [3] TeletexString OPTIONAL,
|
|
private-use
|
|
[4] OCTET STRING
|
|
OPTIONAL -- maximum ub-teletex-private-use-length octets --
|
|
}
|
|
|
|
TOKEN ::= TYPE-IDENTIFIER
|
|
|
|
-- as defined in CCITT Recommendation T.62
|
|
-- Token
|
|
Token ::= SEQUENCE {
|
|
token-type-identifier [0] -- TOKEN.&id({TokensTable})-- TokenTypeIdentifier,
|
|
token
|
|
[1] --TOKEN.&Type({TokensTable}{@token-type-identifier})-- TokenTypeData
|
|
}
|
|
|
|
TokenTypeIdentifier ::= OBJECT IDENTIFIER
|
|
TokenTypeData ::= ANY
|
|
|
|
TokensTable TOKEN ::= {asymmetric-token, ...}
|
|
|
|
asymmetric-token TOKEN ::= {
|
|
AsymmetricToken
|
|
IDENTIFIED BY id-tok-asymmetricToken
|
|
}
|
|
|
|
AsymmetricTokenData ::=
|
|
-- SIGNED
|
|
-- {--SEQUENCE {signature-algorithm-identifier AlgorithmIdentifier,
|
|
name
|
|
CHOICE {recipient-name RecipientName,
|
|
mta
|
|
[3] MTANameAndOptionalGDI },
|
|
time Time,
|
|
signed-data [0] TokenData OPTIONAL,
|
|
encryption-algorithm-identifier
|
|
[1] AlgorithmIdentifier OPTIONAL,
|
|
encrypted-data
|
|
[2] --ENCRYPTED{TokenData}-- BIT STRING OPTIONAL} --}
|
|
|
|
MTANameAndOptionalGDI ::= SEQUENCE {
|
|
global-domain-identifier GlobalDomainIdentifier OPTIONAL,
|
|
mta-name MTAName
|
|
}
|
|
|
|
AsymmetricToken ::= SEQUENCE {
|
|
asymmetric-token-data AsymmetricTokenData,
|
|
algorithm-identifier AlgorithmIdentifier,
|
|
encrypted BIT STRING
|
|
}
|
|
|
|
|
|
TokenData ::= SEQUENCE {
|
|
type [0] -- TOKEN-DATA.&id({TokenDataTable})-- TokenDataType,
|
|
value [1] TOKEN-DATA.&Type({TokenDataTable}{@type})
|
|
}
|
|
|
|
TokenDataType ::= INTEGER {
|
|
bind-token-signed-data (1),
|
|
message-token-signed-data (2),
|
|
message-token-encrypted-data (3),
|
|
bind-token-encrypted-data(4)
|
|
}
|
|
|
|
TOKEN-DATA ::= CLASS {&id INTEGER UNIQUE,
|
|
&Type
|
|
}WITH SYNTAX {&Type
|
|
IDENTIFIED BY &id
|
|
}
|
|
|
|
TokenDataTable TOKEN-DATA ::=
|
|
{bind-token-signed-data | message-token-signed-data |
|
|
message-token-encrypted-data | bind-token-encrypted-data, ...}
|
|
|
|
bind-token-signed-data TOKEN-DATA ::= {BindTokenSignedData
|
|
IDENTIFIED BY 1
|
|
}
|
|
|
|
BindTokenSignedData ::= RandomNumber
|
|
|
|
RandomNumber ::= BIT STRING
|
|
|
|
message-token-signed-data TOKEN-DATA ::= {
|
|
MessageTokenSignedData
|
|
IDENTIFIED BY 2
|
|
}
|
|
|
|
MessageTokenSignedData ::= SEQUENCE {
|
|
content-confidentiality-algorithm-identifier
|
|
[0] ContentConfidentialityAlgorithmIdentifier OPTIONAL,
|
|
content-integrity-check
|
|
[1] ContentIntegrityCheck OPTIONAL,
|
|
message-security-label
|
|
[2] MessageSecurityLabel OPTIONAL,
|
|
proof-of-delivery-request
|
|
[3] ProofOfDeliveryRequest OPTIONAL,
|
|
message-sequence-number [4] INTEGER OPTIONAL
|
|
}
|
|
|
|
message-token-encrypted-data TOKEN-DATA ::= {
|
|
MessageTokenEncryptedData
|
|
IDENTIFIED BY 3
|
|
}
|
|
|
|
MessageTokenEncryptedData ::= SEQUENCE {
|
|
content-confidentiality-key [0] EncryptionKey OPTIONAL,
|
|
content-integrity-check [1] ContentIntegrityCheck OPTIONAL,
|
|
message-security-label [2] MessageSecurityLabel OPTIONAL,
|
|
content-integrity-key [3] EncryptionKey OPTIONAL,
|
|
message-sequence-number [4] INTEGER OPTIONAL
|
|
}
|
|
|
|
EncryptionKey ::= BIT STRING
|
|
|
|
bind-token-encrypted-data TOKEN-DATA ::= {
|
|
BindTokenEncryptedData
|
|
IDENTIFIED BY 4
|
|
}
|
|
|
|
BindTokenEncryptedData ::= EXTERNAL
|
|
|
|
-- Security Label
|
|
SecurityLabel ::= SET {
|
|
security-policy-identifier SecurityPolicyIdentifier OPTIONAL,
|
|
security-classification SecurityClassification OPTIONAL,
|
|
privacy-mark PrivacyMark OPTIONAL,
|
|
security-categories SecurityCategories OPTIONAL
|
|
}
|
|
|
|
SecurityPolicyIdentifier ::= OBJECT IDENTIFIER
|
|
|
|
SecurityClassification ::= INTEGER {
|
|
unmarked(0), unclassified(1), restricted(2), confidential(3), secret(4),
|
|
top-secret(5)}(0..ub-integer-options)
|
|
|
|
PrivacyMark ::= PrintableString(SIZE (1..ub-privacy-mark-length))
|
|
|
|
SecurityCategories ::= SET SIZE (1..ub-security-categories) OF SecurityCategory
|
|
|
|
SECURITY-CATEGORY ::= TYPE-IDENTIFIER
|
|
|
|
SecurityCategory ::= SEQUENCE {
|
|
type [0] --SECURITY-CATEGORY.&id({SecurityCategoriesTable})-- SecurityCategoryIdentifier,
|
|
value [1] --SECURITY-CATEGORY.&Type({SecurityCategoriesTable}{@type})-- SecurityCategoryValue
|
|
}
|
|
|
|
SecurityCategoryIdentifier ::= OBJECT IDENTIFIER
|
|
SecurityCategoryValue ::= ANY
|
|
|
|
|
|
SecurityCategoriesTable SECURITY-CATEGORY ::=
|
|
{...}
|
|
|
|
END -- of MTSAbstractService
|
|
|
|
-- Generated by Asnp, the ASN.1 pretty-printer of France Telecom R&D
|
|
|