Get from
http://www.sisconet.com/downloads/mms_abstract_syntax.txt
---------------------------------------------------------------------
Corrections made July 2, 1994
---------------------------------------------------------------------
MMS { iso standard 9506 part(2) mms-general-module-version(2) }
DEFINITIONS ::=
BEGIN
EXPORTS MMSpdu;
IMPORTS
AP-title,
AP-invocation-identifier,
AE-qualifier,
AE-invocation-identifier
FROM ISO-8650-ACSE-1
MMSpdu ::= CHOICE
{
confirmed-RequestPDU [0] IMPLICIT Confirmed-RequestPDU,
confirmed-ResponsePDU [1] IMPLICIT Confirmed-ResponsePDU,
confirmed-ErrorPDU [2] IMPLICIT Confirmed-ErrorPDU,
unconfirmed-PDU [3] IMPLICIT Unconfirmed-PDU,
rejectPDU [4] IMPLICIT RejectPDU,
cancel-RequestPDU [5] IMPLICIT Cancel-RequestPDU,
cancel-ResponsePDU [6] IMPLICIT Cancel-ResponsePDU,
cancel-ErrorPDU [7] IMPLICIT Cancel-ErrorPDU,
initiate-RequestPDU [8] IMPLICIT Initiate-RequestPDU,
initiate-ResponsePDU [9] IMPLICIT Initiate-ResponsePDU,
initiate-ErrorPDU [10] IMPLICIT Initiate-ErrorPDU,
conclude-RequestPDU [11] IMPLICIT Conclude-RequestPDU,
conclude-ResponsePDU [12] IMPLICIT Conclude-ResponsePDU,
conclude-ErrorPDU [13] IMPLICIT Conclude-ErrorPDU
}
Confirmed-RequestPDU ::= SEQUENCE
{
invokeID Unsigned32,
listOfModifier SEQUENCE OF Modifier OPTIONAL,
ConfirmedServiceRequest,
[79] CS-Request-Detail OPTIONAL
}
Unconfirmed-PDU ::= SEQUENCE
{
UnconfirmedService,
[79] CS-Request-Detail OPTIONAL
}
Confirmed-ResponsePDU ::= SEQUENCE
{
invokeID Unsigned32,
ConfirmedServiceResponse,
[79] CS-Request-Detail OPTIONAL
}
Confirmed-ErrorPDU ::= SEQUENCE
{
invokeID [0] IMPLICIT Unsigned32,
modifierPosition [1] IMPLICIT Unsigned32 OPTIONAL,
serviceError [2] IMPLICIT ServiceError
}
UnconfirmedService ::= CHOICE
{
informationReport [0] IMPLICIT InformationReport,
unsolicitedStatus [1] IMPLICIT UnsolicitedStatus,
eventNotification [2] IMPLICIT EventNotification,
additionalService [3] AdditionalUnconfirmedService
}
Modifier ::= CHOICE
{
attach-To-Event-Condition [0] IMPLICIT AttachToEventCondition,
attach-To-Semaphore [1] IMPLICIT AttachToSemaphore
}
ConfirmedServiceRequest ::= CHOICE
{
status [0] IMPLICIT Status-Request,
getNameList [1] IMPLICIT GetNameList-Request,
identify [2] IMPLICIT Identify-Request,
rename [3] IMPLICIT Rename-Request,
read [4] IMPLICIT Read-Request,
write [5] IMPLICIT Write-Request,
getVariableAccessAttributes [6] GetVariableAccessAttributes-Request,
defineNamedVariable [7] IMPLICIT DefineNamedVariable-Request,
defineScatteredAccess [8] IMPLICIT DefineScatteredAccess-Request,
getScatteredAccessAttributes [9] IMPLICIT GetScatteredAccessAttributes-Request,
deleteVariableAccess [10] IMPLICIT DeleteVariableAccess-Request,
defineNamedVariableList [11] IMPLICIT DefineNamedVariableList-Request,
getNamedVariableListAttributes [12] IMPLICIT GetNamedVariableListAttributes-Request,
deleteNamedVariableList [13] IMPLICIT DeleteNamedVariableList-Request,
defineNamedType [14] IMPLICIT DefineNamedType-Request,
getNamedTypeAttributes [15] IMPLICIT GetNamedTypeAttributes-Request,
deleteNamedType [16] IMPLICIT DeleteNamedType-Request,
input [17] IMPLICIT Input-Request,
output [18] IMPLICIT Output-Request,
takeControl [19] IMPLICIT TakeControl-Request,
relinquishControl [20] IMPLICIT RelinquishControl-Request,
defineSemaphore [21] IMPLICIT DefineSemaphore-Request,
deleteSemaphore [22] IMPLICIT DeleteSemaphore-Request,
reportSemaphoreStatus [23] IMPLICIT ReportSemaphoreStatus-Request,
reportPoolSemaphoreStatus [24] IMPLICIT ReportPoolSemaphoreStatus-Request,
reportSemaphoreEntryStatus [25] IMPLICIT ReportSemaphoreEntryStatus-Request,
initiateDownloadSequence [26] IMPLICIT InitiateDownloadSequence-Request,
downloadSegment [27] IMPLICIT DownloadSegment-Request,
terminateDownloadSequence [28] IMPLICIT TerminateDownloadSequence-Request,
initiateUploadSequence [29] IMPLICIT InitiateUploadSequence-Request,
uploadSegment [30] IMPLICIT UploadSegment-Request,
terminateUploadSequence [31] IMPLICIT TerminateUploadSequence-Request,
requestDomainDownload [32] IMPLICIT RequestDomainDownload-Request,
requestDomainUpload [33] IMPLICIT RequestDomainUpload-Request,
loadDomainContent [34] IMPLICIT LoadDomainContent-Request,
storeDomainContent [35] IMPLICIT StoreDomainContent-Request,
deleteDomain [36] IMPLICIT DeleteDomain-Request,
getDomainAttributes [37] IMPLICIT GetDomainAttributes-Request,
createProgramInvocation [38] IMPLICIT CreateProgramInvocation-Request,
deleteProgramInvocation [39] IMPLICIT DeleteProgramInvocation-Request,
start [40] IMPLICIT Start-Request,
stop [41] IMPLICIT Stop-Request,
resume [42] IMPLICIT Resume-Request,
reset [43] IMPLICIT Reset-Request,
kill [44] IMPLICIT Kill-Request,
getProgramInvocationAttributes [45] IMPLICIT GetProgramInvocationAttributes-Request,
obtainFile [46] IMPLICIT ObtainFile-Request,
defineEventCondition [47] IMPLICIT DefineEventCondition-Request,
deleteEventCondition [48] DeleteEventCondition-Request,
getEventConditionAttributes [49] GetEventConditionAttributes-Request,
reportEventConditionStatus [50] ReportEventConditionStatus-Request,
alterEventConditionMonitoring [51] IMPLICIT AlterEventConditionMonitoring-Request,
triggerEvent [52] IMPLICIT TriggerEvent-Request,
defineEventAction [53] IMPLICIT DefineEventAction-Request,
deleteEventAction [54] DeleteEventAction-Request,
getEventActionAttributes [55] GetEventActionAttributes-Request,
reportEventActionStatus [56] ReportEventActionStatus-Request,
defineEventEnrollment [57] IMPLICIT DefineEventEnrollment-Request,
deleteEventEnrollment [58] DeleteEventEnrollment-Request,
alterEventEnrollment [59] IMPLICIT AlterEventEnrollment-Request,
reportEventEnrollmentStatus [60] ReportEventEnrollmentStatus-Request,
getEventEnrollmentAttributes [61] IMPLICIT GetEventEnrollmentAttributes-Request,
acknowledgeEventNotification [62] IMPLICIT AcknowledgeEventNotification-Request,
getAlarmSummary [63] IMPLICIT GetAlarmSummary-Request,
getAlarmEnrollmentSummary [64] IMPLICIT GetAlarmEnrollmentSummary-Request,
readJournal [65] IMPLICIT ReadJournal-Request,
writeJournal [66] IMPLICIT WriteJournal-Request,
initializeJournal [67] IMPLICIT InitializeJournal-Request,
reportJournalStatus [68] IMPLICIT ReportJournalStatus-Request,
createJournal [69] IMPLICIT CreateJournal-Request,
deleteJournal [70] IMPLICIT DeleteJournal-Request,
getCapabilityList [71] IMPLICIT GetCapabilityList-Request,
fileOpen [72] IMPLICIT FileOpen-Request,
fileRead [73] IMPLICIT FileRead-Request,
fileClose [74] IMPLICIT FileClose-Request,
fileRename [75] IMPLICIT FileRename-Request,
fileDelete [76] IMPLICIT FileDelete-Request,
fileDirectory [77] IMPLICIT FileDirectory-Request,
additionalService [78] AdditionalService-Request
}
CS-Request-Detail ::= CHOICE {
-- see ISO 9506-2
}
ConfirmedServiceResponse ::= CHOICE
{
status [0] IMPLICIT Status-Response,
getNameList [1] IMPLICIT GetNameList-Response,
identify [2] IMPLICIT Identify-Response,
rename [3] IMPLICIT Rename-Response,
read [4] IMPLICIT Read-Response,
write [5] IMPLICIT Write-Response,
getVariableAccessAttributes [6] IMPLICIT GetVariableAccessAttributes-Response,
defineNamedVariable [7] IMPLICIT DefineNamedVariable-Response,
defineScatteredAccess [8] IMPLICIT DefineScatteredAccess-Response,
getScatteredAccessAttributes [9] IMPLICIT GetScatteredAccessAttributes-Response,
deleteVariableAccess [10] IMPLICIT DeleteVariableAccess-Response,
defineNamedVariableList [11] IMPLICIT DefineNamedVariableList-Response,
getNamedVariableListAttributes [12] IMPLICIT GetNamedVariableListAttributes-Response,
deleteNamedVariableList [13] IMPLICIT DeleteNamedVariableList-Response,
defineNamedType [14] IMPLICIT DefineNamedType-Response,
getNamedTypeAttributes [15] IMPLICIT GetNamedTypeAttributes-Response,
deleteNamedType [16] IMPLICIT DeleteNamedType-Response,
input [17] IMPLICIT Input-Response,
output [18] IMPLICIT Output-Response,
takeControl [19] TakeControl-Response,
relinquishControl [20] IMPLICIT RelinquishControl-Response,
defineSemaphore [21] IMPLICIT DefineSemaphore-Response,
deleteSemaphore [22] IMPLICIT DeleteSemaphore-Response,
reportSemaphoreStatus [23] IMPLICIT ReportSemaphoreStatus-Response,
reportPoolSemaphoreStatus [24] IMPLICIT ReportPoolSemaphoreStatus-Response,
reportSemaphoreEntryStatus [25] IMPLICIT ReportSemaphoreEntryStatus-Response,
initiateDownloadSequence [26] IMPLICIT InitiateDownloadSequence-Response,
downloadSegment [27] IMPLICIT DownloadSegment-Response,
terminateDownloadSequence [28] IMPLICIT TerminateDownloadSequence-Response,
initiateUploadSequence [29] IMPLICIT InitiateUploadSequence-Response,
uploadSegment [30] IMPLICIT UploadSegment-Response,
terminateUploadSequence [31] IMPLICIT TerminateUploadSequence-Response,
requestDomainDownLoad [32] IMPLICIT RequestDomainDownload-Response,
requestDomainUpload [33] IMPLICIT RequestDomainUpload-Response,
loadDomainContent [34] IMPLICIT LoadDomainContent-Response,
storeDomainContent [35] IMPLICIT StoreDomainContent-Response,
deleteDomain [36] IMPLICIT DeleteDomain-Response,
getDomainAttributes [37] IMPLICIT GetDomainAttributes-Response,
createProgramInvocation [38] IMPLICIT CreateProgramInvocation-Response,
deleteProgramInvocation [39] IMPLICIT DeleteProgramInvocation-Response,
start [40] IMPLICIT Start-Response,
stop [41] IMPLICIT Stop-Response,
resume [42] IMPLICIT Resume-Response,
reset [43] IMPLICIT Reset-Response,
kill [44] IMPLICIT Kill-Response,
getProgramInvocationAttributes [45] IMPLICIT GetProgramInvocationAttributes-Response,
obtainFile [46] IMPLICIT ObtainFile-Response,
fileOpen [72] IMPLICIT FileOpen-Response,
defineEventCondition [47] IMPLICIT DefineEventCondition-Response,
deleteEventCondition [48] IMPLICIT DeleteEventCondition-Response,
getEventConditionAttributes [49] IMPLICIT GetEventConditionAttributes-Response,
reportEventConditionStatus [50] IMPLICIT ReportEventConditionStatus-Response,
alterEventConditionMonitoring [51] IMPLICIT AlterEventConditionMonitoring-Response,
triggerEvent [52] IMPLICIT TriggerEvent-Response,
defineEventAction [53] IMPLICIT DefineEventAction-Response,
deleteEventAction [54] IMPLICIT DeleteEventAction-Response,
getEventActionAttributes [55] IMPLICIT GetEventActionAttributes-Response,
reportActionStatus [56] IMPLICIT ReportEventActionStatus-Response,
defineEventEnrollment [57] IMPLICIT DefineEventEnrollment-Response,
deleteEventEnrollment [58] IMPLICIT DeleteEventEnrollment-Response,
alterEventEnrollment [59] IMPLICIT AlterEventEnrollment-Response,
reportEventEnrollmentStatus [60] IMPLICIT ReportEventEnrollmentStatus-Response,
getEventEnrollmentAttributes [61] IMPLICIT GetEventEnrollmentAttributes-Response,
acknowledgeEventNotification [62] IMPLICIT AcknowledgeEventNotification-Response,
getAlarmSummary [63] IMPLICIT GetAlarmSummary-Response,
getAlarmEnrollmentSummary [64] IMPLICIT GetAlarmEnrollmentSummary-Response,
readJournal [65] IMPLICIT ReadJournal-Response,
writeJournal [66] IMPLICIT WriteJournal-Response,
initializeJournal [67] IMPLICIT InitializeJournal-Response,
reportJournalStatus [68] IMPLICIT ReportJournalStatus-Response,
createJournal [69] IMPLICIT CreateJournal-Response,
deleteJournal [70] IMPLICIT DeleteJournal-Response,
getCapabilityList [71] IMPLICIT GetCapabilityList-Response,
fileRead [73] IMPLICIT FileRead-Response,
fileClose [74] IMPLICIT FileClose-Response,
fileRename [75] IMPLICIT FileRename-Response,
fileDelete [76] IMPLICIT FileDelete-Response,
fileDirectory [77] IMPLICIT FileDirectory-Response,
additionalService [78] AdditionalService-Response
}
--********************************** COMMON MMS TYPES ***********************************
FileName ::= SEQUENCE OF GraphicString
TimeOfDay ::= OCTET STRING -- (SIZE (4 | 6))
Identifier ::= VisibleString
Integer8 ::= INTEGER
Integer16 ::= INTEGER
Integer32 ::= INTEGER
Unsigned8 ::= INTEGER
Unsigned16 ::= INTEGER
Unsigned32 ::= INTEGER
ObjectName ::= CHOICE
{
vmd-specific [0] IMPLICIT Identifier,
domain-specific [1] IMPLICIT SEQUENCE
{
domainId Identifier,
itemId Identifier
},
aa-specific [2] IMPLICIT Identifier
}
ApplicationReference ::= SEQUENCE
{
ap-title [0] ISO-8650-ACSE-1.AP-title OPTIONAL,
ap-invocation-id [1] ISO-8650-ACSE-1.AP-invocation-identifier OPTIONAL,
ae-qualifier [2] ISO-8650-ACSE-1.AE-qualifier OPTIONAL,
ae-invocation-id [3] ISO-8650-ACSE-1.AE-invocation-identifier OPTIONAL
}
Priority ::= Unsigned8
normalPriority Priority ::= 64
-- ************************************ GENERAL *************************************
Initiate-ErrorPDU ::= ServiceError
Initiate-RequestPDU ::= SEQUENCE
{
localDetailCalling [0] IMPLICIT Integer32 OPTIONAL,
proposedMaxServOutstandingCalling [1] IMPLICIT Integer16,
proposedMaxServOutstandingCalled [2] IMPLICIT Integer16,
proposedDataStructureNestingLevel [3] IMPLICIT Integer8 OPTIONAL,
mmsInitRequestDetail [4] IMPLICIT InitRequestDetail
}
InitRequestDetail ::= SEQUENCE
{
proposedVersionNumber [0] IMPLICIT Integer16,
proposedParameterCBB [1] IMPLICIT ParameterSupportOptions,
servicesSupportedCalling [2] IMPLICIT ServiceSupportOptions
}
Initiate-ResponsePDU ::= SEQUENCE
{
localDetailCalled [0] IMPLICIT Integer32 OPTIONAL,
negociatedMaxServOutstandingCalling [1] IMPLICIT Integer16,
negociatedMaxServOutstandingCalled [2] IMPLICIT Integer16,
negociatedDataStructureNestingLevel [3] IMPLICIT Integer8 OPTIONAL,
mmsInitResponseDetail [4] IMPLICIT InitResponseDetail
}
InitResponseDetail ::= SEQUENCE
{
negociatedVersionNumber [0] IMPLICIT Integer16,
negociatedParameterCBB [1] IMPLICIT ParameterSupportOptions,
servicesSupportedCalled [2] IMPLICIT ServiceSupportOptions
}
ParameterSupportOptions ::= BIT STRING {
str1 (0),
str2 (1),
vnam (2),
valt (3),
vadr (4),
vsca (5),
tpy (6),
vlis (7),
real (8),
cei (10)
}
ServiceSupportOptions ::= BIT STRING
{
status (0),
getNameList (1),
identify (2),
rename (3),
read (4),
write (5),
getVariableAccessAttributes (6),
defineNamedVariable (7),
defineScatteredAccess (8),
getScatteredAccessAttributes (9),
deleteVariableAccess (10),
defineNamedVariableList (11),
getNamedVariableListAttributes (12),
deleteNamedVariableList (13),
defineNamedType (14),
getNamedTypeAttributes (15),
deleteNamedType (16),
input (17),
output (18),
takeControl (19),
relinquishControl (20),
defineSemaphore (21),
deleteSemaphore (22),
reportSemaphoreStatus (23),
reportPoolSemaphoreStatus (24),
reportSemaphoreEntryStatus (25),
initiateDownloadSequence (26),
downloadSegment (27),
terminateDownloadSequence (28),
initiateUploadSequence (29),
uploadSegment (30),
terminateUploadSequence (31),
requestDomainDownload (32),
requestDomainUpload (33),
loadDomainContent (34),
storeDomainContent (35),
deleteDomain (36),
getDomainAttributes (37),
createProgramInvocation (38),
deleteProgramInvocation (39),
start (40),
stop (41),
resume (42),
reset (43),
kill (44),
getProgramInvocationAttributes (45),
obtainFile (46),
defineEventCondition (47),
deleteEventCondition (48),
getEventConditionAttributes (49),
reportEventConditionStatus (50),
alterEventConditionMonitoring (51),
triggerEvent (52),
defineEventAction (53),
deleteEventAction (54),
getEventActionAttributes (55),
reportActionStatus (56),
defineEventEnrollment (57),
deleteEventEnrollment (58),
alterEventEnrollment (59),
reportEventEnrollmentStatus (60),
getEventEnrollmentAttributes (61),
acknowledgeEventNotification (62),
getAlarmSummary (63),
getAlarmEnrollmentSummary (64),
readJournal (65),
writeJournal (66),
initializeJournal (67),
reportJournalStatus (68),
createJournal (69),
deleteJournal (70),
getCapabilityList (71),
fileOpen (72),
fileRead (73),
fileClose (74),
fileRename (75),
fileDelete (76),
fileDirectory (77),
unsolicitedStatus (78),
informationReport (79),
eventNotification (80),
attachToEventCondition (81),
attachToSemaphore (82),
conclude (83),
cancel (84)
}
---------------------------------- CONCLUDE --------------------------------
Conclude-RequestPDU ::= NULL
Conclude-ResponsePDU ::= NULL
Conclude-ErrorPDU ::= ServiceError
---------------------------------- CANCEL --------------------------------
Cancel-RequestPDU ::= Unsigned32 -- originalInvokeID
Cancel-ResponsePDU ::= Unsigned32 -- originalInvokeID
Cancel-ErrorPDU ::= SEQUENCE
{
originalInvokeID [0] IMPLICIT Unsigned32,
serviceError [1] IMPLICIT ServiceError
}
------------------------------ Service-Error --------------------------------
ServiceError ::= SEQUENCE
{
errorClass [0] CHOICE
{
vmd-state [0] IMPLICIT INTEGER
{
other (0),
vmd-state-conflict (1),
vmd-operational-problem (2),
domain-transfer-problem (3),
state-machine-id-invalid (4)
},
application-reference [1] IMPLICIT INTEGER
{
other (0),
aplication-unreachable (1),
connection-lost (2),
application-reference-invalid (3),
context-unsupported (4)
},
definition [2] IMPLICIT INTEGER
{
other (0),
object-undefined (1),
invalid-address (2),
type-unsupported (3),
type-inconsistent (4),
object-exists (5),
object-attribute-inconsistent (6)
},
resource [3] IMPLICIT INTEGER
{
other (0),
memory-unavailable (1),
processor-resource-unavailable (2),
mass-storage-unavailable (3),
capability-unavailable (4),
capability-unknown (5)
},
service [4] IMPLICIT INTEGER
{
other (0),
primitives-out-of-sequence (1),
object-sate-conflict (2),
pdu-size (3),
continuation-invalid (4),
object-constraint-conflict (5)
},
service-preempt [5] IMPLICIT INTEGER
{
other (0),
timeout (1),
deadlock (2),
cancel (3)
},
time-resolution [6] IMPLICIT INTEGER
{
other (0),
unsupportable-time-resolution (1)
},
access [7] IMPLICIT INTEGER
{
other (0),
object-access-unsupported (1),
object-non-existent (2),
object-access-denied (3),
object-invalidated (4)
},
initiate [8] IMPLICIT INTEGER
{
other (0),
version-incompatible (1),
max-segment-insufficient (2),
max-services-outstanding-calling-insufficient (3),
max-services-outstanding-called-insufficient (4),
service-CBB-insufficient (5),
parameter-CBB-insufficient (6),
nesting-level-insufficient (7)
},
conclude [9] IMPLICIT INTEGER
{
other (0),
further-communication-required (1)
},
cancel [10] IMPLICIT INTEGER
{
other (0),
invoke-id-unknown (1),
cancel-not-possible (2)
},
file [11] IMPLICIT INTEGER
{
other (0),
filename-ambiguous (1),
file-busy (2),
filename-syntax-error (3),
content-type-invalid (4),
position-invalid (5),
file-acces-denied (6),
file-non-existent (7),
duplicate-filename (8),
insufficient-space-in-filestore (9)
},
others [12] IMPLICIT INTEGER
},
additionalCode [1] IMPLICIT INTEGER OPTIONAL,
additionalDescription [2] IMPLICIT VisibleString OPTIONAL,
serviceSpecificInformation [3] CHOICE
{
obtainFile [0] IMPLICIT ObtainFile-Error,
start [1] IMPLICIT Start-Error,
stop [2] IMPLICIT Stop-Error,
resume [3] IMPLICIT Resume-Error,
reset [4] IMPLICIT Reset-Error,
deleteVariableAccess [5] IMPLICIT DeleteVariableAccess-Error,
deleteNamedVariableList [6] IMPLICIT DeleteNamedVariableList-Error,
deleteNamedType [7] IMPLICIT DeleteNamedType-Error,
defineEventEnrollment-Error [8] DefineEventEnrollment-Error,
fileRename [9] IMPLICIT FileRename-Error,
additionalService [10] AdditionalServiceError
} OPTIONAL
}
---------------------------------- REJECT --------------------------------
RejectPDU ::= SEQUENCE
{
originalInvokeID [0] IMPLICIT Unsigned32 OPTIONAL,
rejectReason CHOICE
{
confirmed-requestPDU [1] IMPLICIT INTEGER
{
other (0),
unrecognized-service (1),
unrecognized-modifier (2),
invalid-invokeID (3),
invalid-argument (4),
invalid-modifier (5),
max-serv-outstanding-exceeded (6),
max-recursion-exceeded (8),
value-out-of-range (9)
},
confirmed-responsePDU [2] IMPLICIT INTEGER
{
other (0),
unrecognized-service (1),
invalid-invokeID (2),
invalid-result (3),
max-recursion-exceeded (5),
value-out-of-range (6)
},
confirmed-errorPDU [3] IMPLICIT INTEGER
{
other (0),
unrecognized-service (1),
invalid-invokeID (2),
invalid-serviceError (3),
value-out-of-range (4)
} ,
unconfirmedPDU [4] IMPLICIT INTEGER
{
other (0),
unrecognized-service (1),
invalid-argument (2),
max-recursion-exceeded (3),
value-out-of-range (4)
},
pdu-error [5] IMPLICIT INTEGER
{
unknown-pdu-type (0),
invalid-pdu (1),
illegal-acse-mapping (2)
},
cancel-requestPDU [6] IMPLICIT INTEGER
{
other (0),
invalid-invokeID (1)
},
cancel-responsePDU [7] IMPLICIT INTEGER
{
other (0),
invalid-invokeID (1)
},
cancel-errorPDU [8] IMPLICIT INTEGER
{
other (0),
invalid-invokeID (1),
invalid-serviceError (2),
value-out-of-range (3)
},
conclude-requestPDU [9] IMPLICIT INTEGER
{
other (0),
invalid-argument (1)
},
conclude-responsePDU [10] IMPLICIT INTEGER
{
other (0),
invalid-result (1)
},
conclude-errorPDU [11] IMPLICIT INTEGER
{
other (0),
invalid-serviceError (1),
value-out-of-range (2)
}
}
}
-- *************************************** VMD ********************************************
Status-Request ::= BOOLEAN
Status-Response ::= SEQUENCE {
vmdLogicalStatus [0] IMPLICIT INTEGER {
state-changes-allowed (0),
no-state-changes-allowed (1),
limited-services-allowed (2),
support-services-allowed (3)
},
vmdPhysicalStatus [1] IMPLICIT INTEGER {
operational (0),
partially-operational (1),
inoperable (2),
needs-commissioning (3)
},
localDetail [2] IMPLICIT BIT STRING(SIZE(0..128)) OPTIONAL
}
------------------------------- UNSOLICITEDSTATUS --------------------------------
UnsolicitedStatus ::= Status-Response
--------------------------------- GETNAMELIST --------------------------------
GetNameList-Request ::= SEQUENCE
{
extendedObjectClass [0] CHOICE
{
objectClass [0] IMPLICIT INTEGER
{
nammedVariable (0),
scatteredAccess (1),
namedVariableList (2),
namedType (3),
semaphore (4),
eventCondition (5),
eventAction (6),
eventEnrollment (7),
journal (8),
domain (9),
programInvocation (10),
operatorStation (11)
}
},
objectScope [1] CHOICE
{
vmdSpecific [0] IMPLICIT NULL,
domainSpecific [1] IMPLICIT Identifier,
aaSpecific [2] IMPLICIT NULL
},
continueAfter [2] IMPLICIT Identifier OPTIONAL
}
GetNameList-Response ::= SEQUENCE
{
listOfIdentifier [0] IMPLICIT SEQUENCE OF Identifier,
moreFollows [1] IMPLICIT BOOLEAN DEFAULT TRUE
}
---------------------------------- IDENTIFY --------------------------------
Identify-Request ::= NULL
Identify-Response ::= SEQUENCE {
vendorName [0] IMPLICIT VisibleString,
modelName [1] IMPLICIT VisibleString,
revision [2] IMPLICIT VisibleString,
listOfAbstractSyntaxes [3] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL
}
---------------------------------- RENAME --------------------------------
Rename-Request ::= SEQUENCE
{
extendedObjectClass [0] CHOICE {
objectClass [0] IMPLICIT INTEGER
{
namedVariable (0),
scatteredAccess (1),
namedVariableList (2),
namedType (3),
semaphore (4),
eventCondition (5),
eventAction (6),
eventEnrollment (7),
journal (8),
domain (9),
programInvocation (10),
operatorStation (11)
}
},
currentName [1] ObjectName,
newIdentifier [2] IMPLICIT Identifier
}
Rename-Response ::= NULL
---------------------------------- GET CAPABILITY LIST --------------------------------
GetCapabilityList-Request ::= SEQUENCE {
continueAfter VisibleString OPTIONAL
}
GetCapabilityList-Response ::= SEQUENCE {
listOfCapabilities [0] IMPLICIT SEQUENCE OF VisibleString,
moreFollows [1] IMPLICIT BOOLEAN DEFAULT TRUE
}
-- ************************************* DOMAIN ****************************************
InitiateDownloadSequence-Request ::= SEQUENCE
{
domainName [0] IMPLICIT Identifier,
listOfCapabilities [1] IMPLICIT SEQUENCE OF VisibleString,
sharable [2] IMPLICIT BOOLEAN
}
InitiateDownloadSequence-Response ::= NULL
---------------------------------- DOWNLOAD SEGMENT -----------------------------------
DownloadSegment-Request ::= Identifier
DownloadSegment-Response ::= SEQUENCE
{
loadData CHOICE {
non-coded [0] IMPLICIT OCTET STRING,
coded EXTERNAL
},
moreFollows [1] IMPLICIT BOOLEAN DEFAULT TRUE
}
-------------------------------- TERMINATE DOWNLOAD -----------------------------------
TerminateDownloadSequence-Request ::= SEQUENCE
{
domainName [0] IMPLICIT Identifier,
discard [1] IMPLICIT ServiceError OPTIONAL
}
TerminateDownloadSequence-Response ::= NULL
-------------------------------- INITIATE UPLOAD -----------------------------------
InitiateUploadSequence-Request ::= Identifier -- Domain Name
InitiateUploadSequence-Response ::= SEQUENCE
{
ulsmID [0] IMPLICIT Integer32,
listOfCapabilities [1] IMPLICIT SEQUENCE OF VisibleString
}
---------------------------------- UPLOAD SEGMENT -----------------------------------
UploadSegment-Request ::= Integer32 -- ULSM Identifier
UploadSegment-Response ::= SEQUENCE
{
loadData CHOICE {
non-coded [0] IMPLICIT OCTET STRING,
coded EXTERNAL
},
moreFollows [1] IMPLICIT BOOLEAN DEFAULT TRUE
}
-------------------------------- TERMINATE UPLOAD -----------------------------------
TerminateUploadSequence-Request ::= Integer32 -- ULSM Identifer
TerminateUploadSequence-Response ::= NULL
----------------------------- REQUEST DOMAIN DOWNLOAD -----------------------------------
RequestDomainDownload-Request ::= SEQUENCE
{
domainName [0] IMPLICIT Identifier,
listOfCapabilities [1] IMPLICIT SEQUENCE OF VisibleString OPTIONAL,
sharable [2] IMPLICIT BOOLEAN,
fileName [4] IMPLICIT FileName
}
RequestDomainDownload-Response ::= NULL
----------------------------- REQUEST DOMAIN UPLOAD -----------------------------------
RequestDomainUpload-Request ::= SEQUENCE
{
domainName [0] IMPLICIT Identifier,
fileName [1] IMPLICIT FileName
}
RequestDomainUpload-Response ::= NULL
----------------------------- LOAD DOMAIN CONTENT -----------------------------------
LoadDomainContent-Request ::= SEQUENCE
{
domainName [0] IMPLICIT Identifier,
listOfCapabilities [1] IMPLICIT SEQUENCE OF VisibleString OPTIONAL,
sharable [2] IMPLICIT BOOLEAN,
fileName [4] IMPLICIT FileName,
thirdParty [5] IMPLICIT ApplicationReference OPTIONAL
}
LoadDomainContent-Response ::= NULL
----------------------------- STORE DOMAIN CONTENT -----------------------------------
StoreDomainContent-Request ::= SEQUENCE
{
domainName [0] IMPLICIT Identifier,
filenName [1] IMPLICIT FileName,
thirdParty [2] IMPLICIT ApplicationReference OPTIONAL
}
StoreDomainContent-Response ::= NULL
----------------------------- DELETE DOMAIN -----------------------------------
DeleteDomain-Request ::= Identifier -- Domain Name
DeleteDomain-Response ::= NULL
----------------------------- GET DOMAIN ATTRIBUTES -----------------------------------
GetDomainAttributes-Request ::= Identifier -- Domain Name
GetDomainAttributes-Response ::= SEQUENCE
{
listOfCapabilities [0] IMPLICIT SEQUENCE OF VisibleString,
state [1] IMPLICIT DomainState,
mmsDeletable [2] IMPLICIT BOOLEAN,
sharable [3] IMPLICIT BOOLEAN,
listOfProgramInvocations [4] IMPLICIT SEQUENCE OF Identifier, -- PI Names
uploadInProgress [5] IMPLICIT Integer8
}
DomainState ::= INTEGER
{
non-existent (0),
loading (1),
ready (2),
in-use (3),
complete (4),
incomplete (5),
d1 (7),
d2 (8),
d3 (9),
d4 (10),
d5 (11),
d6 (12),
d7 (13),
d8 (14),
d9 (15)
}
-- ********************************* PROGRAM INVOCATION *********************************
----------------------CREATE PROGRAM INVOCATION ---------------------
CreateProgramInvocation-Request ::= SEQUENCE
{
programInvocationName [0] IMPLICIT Identifier,
listOfDomainName [1] IMPLICIT SEQUENCE OF Identifier,
reusable [2] IMPLICIT BOOLEAN DEFAULT TRUE,
monitorType [3] IMPLICIT BOOLEAN OPTIONAL
-- TRUE indicates PERMANENT monitoring
-- FALSE indicates CURRENT monitoring
}
CreateProgramInvocation-Response ::= NULL
----------------------DELETE PROGRAM INVOCATION ---------------------
DeleteProgramInvocation-Request ::= Identifier -- Program Invocation Name
DeleteProgramInvocation-Response ::= NULL
----------------------------- START ------------------------------------
Start-Request ::= SEQUENCE
{
programInvocationName [0] IMPLICIT Identifier,
executionArgument CHOICE {
simpleString [1] IMPLICIT VisibleString,
encodedString EXTERNAL
} OPTIONAL
}
Start-Response ::= NULL
Start-Error ::= ProgramInvocationState
----------------------------- STOP ------------------------------------
Stop-Request ::= SEQUENCE
{
programInvocationName [0] IMPLICIT Identifier
}
Stop-Response ::= NULL
Stop-Error ::= ProgramInvocationState
---------------------------- RESUME ------------------------------------
Resume-Request ::= SEQUENCE
{
programInvocationName [0] IMPLICIT Identifier,
executionArgument CHOICE {
simpleString [1] IMPLICIT VisibleString,
encodedString EXTERNAL
} OPTIONAL
}
Resume-Response ::= NULL
Resume-Error ::= ProgramInvocationState
------------------------------ RESET ------------------------------------
Reset-Request ::= SEQUENCE
{
programInvocationName [0] IMPLICIT Identifier
}
Reset-Response ::= NULL
Reset-Error ::= ProgramInvocationState
------------------------------ KILL ------------------------------------
Kill-Request ::= SEQUENCE
{
programInvocationName [0] IMPLICIT Identifier
}
Kill-Response ::= NULL
--------------------------- GET PI ATTRIBUTES ------------------------------------
GetProgramInvocationAttributes-Request ::= Identifier -- Program Invocation Name
GetProgramInvocationAttributes-Response ::= SEQUENCE
{
state [0] IMPLICIT ProgramInvocationState,
listOfDomainNames [1] IMPLICIT SEQUENCE OF Identifier,
mmsDeletable [2] IMPLICIT BOOLEAN,
reusable [3] IMPLICIT BOOLEAN,
monitor [4] IMPLICIT BOOLEAN,
startArgument [5] IMPLICIT VisibleString,
executionArgument CHOICE {
simpleString [1] IMPLICIT VisibleString,
encodedString EXTERNAL
} OPTIONAL
}
ProgramInvocationState ::= INTEGER
{
non-existent (0),
unrunable (1),
idle (2),
running (3),
stopped (4),
starting (5),
stopping (6),
resuming (7),
resetting (8)
}
-- Companion Standard may add additional values
-- *********************************** VARIABLES ****************************************
TypeSpecification ::= CHOICE
{
typeName [0] ObjectName,
array [1] IMPLICIT SEQUENCE
{
packed [0] IMPLICIT BOOLEAN DEFAULT FALSE,
numberOfElements [1] IMPLICIT Unsigned32,
elementType [2] TypeSpecification,
},
structure [2] IMPLICIT SEQUENCE
{
packed [0] IMPLICIT BOOLEAN DEFAULT FALSE,
components [1] IMPLICIT SEQUENCE OF SEQUENCE
{
componentName [0] IMPLICIT Identifier OPTIONAL,
componentType [1] TypeSpecification
}
},
-- Simple Type -------- Size ---------
boolean [3] IMPLICIT NULL,
bit-string [4] IMPLICIT Integer32,
integer [5] IMPLICIT Unsigned8,
unsigned [6] IMPLICIT Unsigned8,
octet-string [9] IMPLICIT Integer32,
visible-string [10] IMPLICIT Integer32,
generalized-time [11] IMPLICIT NULL,
binary-time [12] IMPLICIT BOOLEAN,
bcd [13] IMPLICIT Unsigned8,
objId [15] IMPLICIT NULL
}
AlternateAccess ::= SEQUENCE OF CHOICE
{
unnamed AlternateAccessSelection,
named [5] IMPLICIT SEQUENCE
{
componentName [0] IMPLICIT Identifier,
accesst AlternateAccessSelection
}
}
AlternateAccessSelection ::= CHOICE
{
selectAccess CHOICE
{
component [1] IMPLICIT Identifier,
index [2] IMPLICIT Unsigned32,
indexRange [3] IMPLICIT SEQUENCE
{
lowIndex [0] IMPLICIT Unsigned32,
numberOfElements [1] IMPLICIT Unsigned32
},
allElements [4] IMPLICIT NULL -- all array elements
}
}
-------------------------------- READ -------------------------------
Read-Request ::= SEQUENCE
{
specificationWithResult [0] IMPLICIT BOOLEAN DEFAULT FALSE,
variableAccessSpecificatn [1] VariableAccessSpecification
}
Read-Response ::= SEQUENCE
{
variableAccessSpecificatn [0] VariableAccessSpecification OPTIONAL,
listOfAccessResult [1] IMPLICIT SEQUENCE OF AccessResult
}
-------------------------------- WRITE -------------------------------
Write-Request ::= SEQUENCE
{
variableAccessSpecificatn VariableAccessSpecification,
listOfData [0] IMPLICIT SEQUENCE OF Data
}
Write-Response ::= SEQUENCE OF CHOICE
{
failure [0] IMPLICIT DataAccessError,
success [1] IMPLICIT NULL
}
---------------------------- INFORMATION REPORT --------------------------------
InformationReport ::= SEQUENCE
{
variableAccessSpecification VariableAccessSpecification,
listOfAccessResult [0] IMPLICIT SEQUENCE OF AccessResult
}
------------------------- GET VARIABLE ACCESS ATTRIBUTES ------------------------
GetVariableAccessAttributes-Request ::= CHOICE
{
name [0] ObjectName,
address [1] Address
}
GetVariableAccessAttributes-Response ::= SEQUENCE
{
mmsDeletable [0] IMPLICIT BOOLEAN,
address [1] Address OPTIONAL,
typeSpecification [2] TypeSpecification
}
--------------------------- DEFINE NAMED VARIABLE --------------------------------
DefineNamedVariable-Request ::= SEQUENCE
{
variableName [0] ObjectName,
address [1] Address,
typeSpecification [2] TypeSpecification OPTIONAL
}
DefineNamedVariable-Response ::= NULL
-------------------------- DEFINE SCATTERED ACCESS -------------------------------
DefineScatteredAccess-Request ::= SEQUENCE
{
scatteredAccessName [0] ObjectName,
scatteredAccessDescription [1] IMPLICIT ScatteredAccessDescription
}
DefineScatteredAccess-Response ::= NULL
------------------------- GET SCATTERED ACCESS ATTRIBUTES ------------------------
GetScatteredAccessAttributes-Request ::= ObjectName -- ScatteredAccessName
GetScatteredAccessAttributes-Response ::= SEQUENCE
{
mmsDeletable [0] IMPLICIT BOOLEAN,
scatteredAccessDescription [1] IMPLICIT ScatteredAccessDescription
}
----------------------------- DELETE VARIABLE ACCESS ------------------------------
DeleteVariableAccess-Request ::= SEQUENCE
{
scopeOfDelete [0] IMPLICIT INTEGER
{
specific (0),
aa-specific (1),
domain (2),
vmd (3)
} DEFAULT specific,
listOfName [1] IMPLICIT SEQUENCE OF ObjectName OPTIONAL,
domainName [2] IMPLICIT Identifier OPTIONAL
}
DeleteVariableAccess-Response ::= SEQUENCE
{
numberMatched [0] IMPLICIT Unsigned32,
numberDeleted [1] IMPLICIT Unsigned32
}
DeleteVariableAccess-Error ::= Unsigned32 -- numberDeleted
------------------------- DEFINE NAMED VAR. LIST -------------------------------
DefineNamedVariableList-Request ::= SEQUENCE
{
variableListName ObjectName,
listOfVariable [0] IMPLICIT SEQUENCE OF SEQUENCE
{
variableSpecification VariableSpecification,
alternateAccess [5] IMPLICIT AlternateAccess OPTIONAL
}
}
DefineNamedVariableList-Response ::= NULL
------------------------- GET NAMED VAR. LIST ATTRIBUTES ------------------------
GetNamedVariableListAttributes-Request ::= ObjectName -- VariableListName
GetNamedVariableListAttributes-Response ::= SEQUENCE
{
mmsDeletable [0] IMPLICIT BOOLEAN,
listOfVariable [1] IMPLICIT SEQUENCE OF SEQUENCE
{
variableSpecification VariableSpecification,
alternateAccess [5] IMPLICIT AlternateAccess OPTIONAL
}
}
------------------------- DELETE NAMED VAR. LIST -------------------------------
DeleteNamedVariableList-Request ::= SEQUENCE
{
scopeOfDelete [0] IMPLICIT INTEGER
{
specific (0),
aa-specific (1),
domain (2),
vmd (3)
} DEFAULT specific,
listOfVariableListName [1] IMPLICIT SEQUENCE OF ObjectName OPTIONAL,
domainName [2] IMPLICIT Identifier OPTIONAL
}
DeleteNamedVariableList-Response ::= SEQUENCE
{
numberMatched [0] IMPLICIT Unsigned32,
numberDeleted [1] IMPLICIT Unsigned32
}
DeleteNamedVariableList-Error ::= Unsigned32 -- number Deleted
------------------------- DEFINE NAMED TYPE -------------------------------
DefineNamedType-Request ::= SEQUENCE
{
typeName ObjectName,
typeSpecification TypeSpecification
}
DefineNamedType-Response ::= NULL
------------------------- GET NAMED TYPE ATTRIB. -------------------------------
GetNamedTypeAttributes-Request ::= ObjectName -- TypeName
GetNamedTypeAttributes-Response ::= SEQUENCE
{
mmsDeletable [0] IMPLICIT BOOLEAN,
typeSpecification TypeSpecification
}
------------------------- DELETE NAMED TYPE -------------------------------
DeleteNamedType-Request ::= SEQUENCE
{
scopeOfDelete [0] IMPLICIT INTEGER
{
specific (0),
aa-specific (1),
domain (2),
vmd (3)
} DEFAULT specific,
listOfTypeName [1] IMPLICIT SEQUENCE OF ObjectName OPTIONAL,
domainName [2] IMPLICIT Identifier OPTIONAL
}
DeleteNamedType-Response ::= SEQUENCE
{
numberMatched [0] IMPLICIT Unsigned32,
numberDeleted [1] IMPLICIT Unsigned32
}
DeleteNamedType-Error ::= Unsigned32 -- number Deleted
---------------------------- SUPPORT DEFINITIONS ----------------------------
AccessResult ::= CHOICE
{
failure [0] IMPLICIT DataAccessError,
success Data
}
DataAccessError ::= INTEGER
{
object-invalidated (0),
hardware-fault (1),
temporarly-unavailable (2),
object-access-denied (3),
object-undefined (4),
invalid-address (5),
type-unsupported (6),
type-inconsistent (7),
object-attribute-inconsistent (8),
object-access-unsupported (9),
object-non-existent (10)
}
Data ::= CHOICE
{
-- context tag 0 is reserved for AccessResult
array [1] IMPLICIT SEQUENCE OF Data,
structure [2] IMPLICIT SEQUENCE OF Data,
boolean [3] IMPLICIT BOOLEAN,
bit-string [4] IMPLICIT BIT STRING,
integer [5] IMPLICIT INTEGER,
unsigned [6] IMPLICIT INTEGER,
floating-point [7] IMPLICIT FloatingPoint,
real [8] IMPLICIT REAL,
octet-string [9] IMPLICIT OCTET STRING,
visible-string [10] IMPLICIT VisibleString,
binary-time [12] IMPLICIT TimeOfDay,
bcd [13] IMPLICIT INTEGER,
booleanArray [14] IMPLICIT BIT STRING
}
FloatingPoint ::= OCTET STRING
VariableAccessSpecification ::= CHOICE
{
listOfVariable [0] IMPLICIT SEQUENCE OF SEQUENCE
{
variableSpecification VariableSpecification,
alternateAccess [5] IMPLICIT AlternateAccess OPTIONAL
},
variableListName [1] ObjectName
}
ScatteredAccessDescription ::= SEQUENCE OF SEQUENCE
{
componentName [0] IMPLICIT Identifier OPTIONAL,
variableSpecification [1] VariableSpecification,
alternateAccess [2] IMPLICIT AlternateAccess OPTIONAL
}
VariableSpecification ::= CHOICE
{
name [0] ObjectName,
address [1] Address,
variableDescription [2] IMPLICIT SEQUENCE
{
address Address,
typeSpecification TypeSpecification
},
scatteredAccessDescription [3] IMPLICIT ScatteredAccessDescription,
invalidated [4] IMPLICIT NULL
}
Address ::= CHOICE
{
numericAddress [0] IMPLICIT Unsigned32,
symbolicAddress [1] IMPLICIT VisibleString,
unconstrainedAddress [2] IMPLICIT OCTET STRING
}
-- ********************************* SEMAPHORES *****************************************
TakeControl-Request ::= SEQUENCE
{
semaphoreName [0] ObjectName,
namedToken [1] IMPLICIT Identifier OPTIONAL,
priority [2] IMPLICIT Priority DEFAULT 64,
acceptableDelay [3] IMPLICIT Unsigned32 OPTIONAL,
controlTimeOut [4] IMPLICIT Unsigned32 OPTIONAL,
abortOnTimeOut [5] IMPLICIT BOOLEAN OPTIONAL,
relinquishIfConnectionLost [6] IMPLICIT BOOLEAN DEFAULT TRUE,
applicationToPreempt [7] IMPLICIT ApplicationReference OPTIONAL
}
TakeControl-Response ::= CHOICE
{
noResult [0] IMPLICIT NULL,
namedToken [1] IMPLICIT Identifier
}
-------------------------------- RELINQUISH CONTROL -----------------------------
RelinquishControl-Request ::= SEQUENCE
{
semaphoreName [0] ObjectName,
namedToken [1] IMPLICIT Identifier OPTIONAL
}
RelinquishControl-Response ::= NULL
------------------------------- DEFINE SEMAPHORE --------------------------------
DefineSemaphore-Request ::= SEQUENCE
{
semaphoreName [0] ObjectName,
numbersOfTokens [1] IMPLICIT Unsigned16
}
DefineSemaphore-Response ::= NULL
------------------------------- DELETE SEMAPHORE --------------------------------
DeleteSemaphore-Request ::= ObjectName -- Semaphore Name
DeleteSemaphore-Response ::= NULL
--------------------------- REPORT SEMAPHORE STATUS -----------------------------
ReportSemaphoreStatus-Request ::= ObjectName -- SemaphoreName
ReportSemaphoreStatus-Response ::= SEQUENCE
{
mmsDeletable [0] IMPLICIT BOOLEAN,
class [1] IMPLICIT INTEGER
{
token (0),
pool (1)
},
numberOfTokens [2] IMPLICIT Unsigned16,
numberOfOwnedTokens [3] IMPLICIT Unsigned16,
numberOfHungTokens [4] IMPLICIT Unsigned16
}
--------------------------- REPORT POOL SEMAPHORE STATUS -----------------------------
ReportPoolSemaphoreStatus-Request ::= SEQUENCE
{
semaphoreName [0] ObjectName,
nameToStartAfter [1] IMPLICIT Identifier OPTIONAL
}
ReportPoolSemaphoreStatus-Response ::= SEQUENCE
{
listOfNamedTokens [0] IMPLICIT SEQUENCE OF CHOICE
{
freeNamedToken [0] IMPLICIT Identifier,
ownedNamedToken [1] IMPLICIT Identifier,
hungNamedToken [2] IMPLICIT Identifier
},
moreFollows [1] IMPLICIT BOOLEAN DEFAULT TRUE
}
--------------------------- REPORT SEMAPHORE ENTRY STATUS -----------------------------
ReportSemaphoreEntryStatus-Request ::=SEQUENCE
{
semaphoreName [0] ObjectName,
state [1] IMPLICIT INTEGER
{
queued (0),
owner (1),
hung (2)
} ,
entryIdToStartAfter [2] IMPLICIT OCTET STRING OPTIONAL
}
ReportSemaphoreEntryStatus-Response ::= SEQUENCE
{
listOfSemaphoreEntry [0] IMPLICIT SEQUENCE OF SemaphoreEntry,
moreFollows [1] IMPLICIT BOOLEAN DEFAULT TRUE
}
AttachToSemaphore ::= SEQUENCE
{
semaphoreName [0] ObjectName,
namedToken [1] IMPLICIT Identifier OPTIONAL,
priority [2] IMPLICIT Priority DEFAULT 64,
acceptableDelay [3] IMPLICIT Unsigned32 OPTIONAL,
controlTimeOut [4] IMPLICIT Unsigned32 OPTIONAL,
abortOnTimeOut [5] IMPLICIT BOOLEAN OPTIONAL,
relinquishIfConnectionLost [6] IMPLICIT BOOLEAN DEFAULT TRUE
}
SemaphoreEntry ::= SEQUENCE
{
entryId [0] IMPLICIT OCTET STRING,
entryClass [1] IMPLICIT INTEGER
{
simple (0),
modifier (1)
},
applicationReference [2] ApplicationReference,
namedToken [3] IMPLICIT Identifier OPTIONAL,
priority [4] IMPLICIT Priority DEFAULT 64,
remainingTimeOut [5] IMPLICIT Unsigned32 OPTIONAL,
abortOnTimeOut [6] IMPLICIT BOOLEAN OPTIONAL,
relinquishIfConnectionLost [7] IMPLICIT BOOLEAN DEFAULT TRUE
}
--******************************** OPERATOR COMMUNICATION *****************************
------------------------------------------ INPUT ------------------------------------
Input-Request ::= SEQUENCE
{
operatorStationName [0] IMPLICIT Identifier,
echo [1] IMPLICIT BOOLEAN DEFAULT TRUE,
listOfPromptData [2] IMPLICIT SEQUENCE OF VisibleString OPTIONAL,
inputTimeOut [3] IMPLICIT Unsigned32 OPTIONAL
}
Input-Response ::= VisibleString -- Input String
--------------------------------------- OUTPUT -------------------------------------
Output-Request ::= SEQUENCE
{
operatorStationName [0] IMPLICIT Identifier,
listOfOutputData [1] IMPLICIT SEQUENCE OF VisibleString
}
Output-Response ::= NULL
-- ************************************ EVENTS *********************************************
DefineEventCondition-Request ::= SEQUENCE
{
eventConditionName [0] ObjectName,
class [1] IMPLICIT EC-Class,
prio-rity [2] IMPLICIT Priority DEFAULT 64,
severity [3] IMPLICIT Unsigned8 DEFAULT 64,
alarmSummaryReports [4] IMPLICIT BOOLEAN OPTIONAL,
monitoredVariable [6] VariableSpecification OPTIONAL,
evaluationInterval [7] IMPLICIT Unsigned32 OPTIONAL
}
DefineEventCondition-Response ::= NULL
DeleteEventCondition-Request ::= CHOICE
{
specific [0] IMPLICIT SEQUENCE OF ObjectName,
aa-specific [1] IMPLICIT NULL,
domain [2] IMPLICIT Identifier,
vmd [3] IMPLICIT NULL
}
DeleteEventCondition-Response ::= Unsigned32 -- Candidates Not Deleted
GetEventConditionAttributes-Request ::= ObjectName -- Event Condition Name
GetEventConditionAttributes-Response ::= SEQUENCE
{
mmsDeletable [0] IMPLICIT BOOLEAN DEFAULT FALSE,
class [1] IMPLICIT EC-Class,
prio-rity [2] IMPLICIT Priority DEFAULT 64,
severity [3] IMPLICIT Unsigned8 DEFAULT 64,
alarmSummaryReports [4] IMPLICIT BOOLEAN DEFAULT FALSE,
monitoredVariable [6] CHOICE
{
variableReference [0] VariableSpecification,
undefined [1] IMPLICIT NULL
} OPTIONAL,
evaluationInterval [7] IMPLICIT Unsigned32 OPTIONAL
}
ReportEventConditionStatus-Request ::= ObjectName -- EventConditionName
ReportEventConditionStatus-Response ::= SEQUENCE
{
currentState [0] IMPLICIT EC-State,
numberOfEventEnrollments [1] IMPLICIT Unsigned32,
enabled [2] IMPLICIT BOOLEAN OPTIONAL,
timeOfLastTransitionToActive [3] EventTime OPTIONAL,
timeOfLastTransitionToIdle [4] EventTime OPTIONAL
}
AlterEventConditionMonitoring-Request ::= SEQUENCE
{
eventConditionName [0] ObjectName,
enabled [1] IMPLICIT BOOLEAN OPTIONAL,
priority [2] IMPLICIT Priority OPTIONAL,
alarmSummaryReports [3] IMPLICIT BOOLEAN OPTIONAL,
evaluationInterval [4] IMPLICIT Unsigned32 OPTIONAL
}
AlterEventConditionMonitoring-Response ::= NULL
TriggerEvent-Request ::= SEQUENCE
{
eventConditionName [0] ObjectName,
priority [1] IMPLICIT Priority OPTIONAL
}
TriggerEvent-Response ::= NULL
DefineEventAction-Request ::= SEQUENCE
{
eventActionName [0] ObjectName,
listOfModifier [1] IMPLICIT SEQUENCE OF Modifier OPTIONAL,
confirmed-Service-Request [2] DefineEventAction-ConfirmedServiceRequest
}
DefineEventAction-Response ::= NULL
DeleteEventAction-Request ::= CHOICE
{
specific [0] IMPLICIT SEQUENCE OF ObjectName,
aa-specific [1] IMPLICIT NULL,
domain [3] IMPLICIT Identifier,
vmd [4] IMPLICIT NULL
}
DeleteEventAction-Response ::= Unsigned32 -- candidates not deleted
GetEventActionAttributes-Request ::= ObjectName -- Event Action Name
GetEventActionAttributes-Response ::= SEQUENCE
{
mmsDeletable [0] IMPLICIT BOOLEAN DEFAULT FALSE,
listOfModifier [1] IMPLICIT SEQUENCE OF Modifier,
confirmed-Service-Request [2] DefineEventAction-ConfirmedServiceRequest
}
ReportEventActionStatus-Request ::= ObjectName -- EventActionName
ReportEventActionStatus-Response ::= Unsigned32 -- Number of Event Enrollments
DefineEventEnrollment-Request ::= SEQUENCE
{
eventEnrollmentName [0] ObjectName,
eventConditionName [1] ObjectName,
eventConditionTransition [2] IMPLICIT Transitions,
alarmAcknowledgementRule [3] IMPLICIT AlarmAckRule,
eventActionName [4] ObjectName OPTIONAL,
clientApplication [5] ApplicationReference OPTIONAL
}
DefineEventEnrollment-Response ::= NULL
DefineEventEnrollment-Error ::= ObjectName
DeleteEventEnrollment-Request ::= CHOICE
{
specific [0] IMPLICIT SEQUENCE OF ObjectName,
ec [1] ObjectName,
ea [2] ObjectName
}
DeleteEventEnrollment-Response ::= Unsigned32 -- candidates not deleted
GetEventEnrollmentAttributes-Request ::= SEQUENCE
{
scopeOfRequest [0] IMPLICIT INTEGER
{
specific (0),
client (1),
ec (2),
ea (3)
} DEFAULT client,
eventEnrollmentNames [1] IMPLICIT SEQUENCE OF ObjectName OPTIONAL,
clientApplication [2] ApplicationReference OPTIONAL,
eventConditionName [3] ObjectName OPTIONAL,
eventActionName [4] ObjectName OPTIONAL,
continueAfter [5] ObjectName OPTIONAL
}
EventEnrollment ::= SEQUENCE
{
eventEnrollmentName [0] ObjectName,
eventConditionName [1] CHOICE
{
eventCondition [0] ObjectName,
undefined [1] IMPLICIT NULL
},
eventActionName [2] CHOICE
{
eventAction [0] ObjectName,
undefined [1] IMPLICIT NULL
} OPTIONAL,
clientApplication [3] ApplicationReference OPTIONAL,
mmsDeletable [4] IMPLICIT BOOLEAN DEFAULT FALSE,
enrollmentClass [5] IMPLICIT EE-Class,
duration [6] IMPLICIT EE-Duration DEFAULT current,
invokeID [7] IMPLICIT Unsigned32,
remainingAcceptableDelay [8] IMPLICIT Unsigned32 OPTIONAL
}
GetEventEnrollmentAttributes-Response ::= SEQUENCE
{
listOfEventEnrollment [0] IMPLICIT SEQUENCE OF EventEnrollment,
moreFollows [1] IMPLICIT BOOLEAN DEFAULT FALSE
}
ReportEventEnrollmentStatus-Request ::= ObjectName -- Event Enrollment Name
ReportEventEnrollmentStatus-Response ::= SEQUENCE
{
eventConditionTransitions [0] IMPLICIT Transitions,
notificationLost [1] IMPLICIT BOOLEAN DEFAULT FALSE,
duration [2] IMPLICIT EE-Duration,
alarmAcknowledgmentRule [3] IMPLICIT AlarmAckRule OPTIONAL,
currentState [4] IMPLICIT EE-State
}
AlterEventEnrollment-Request ::= SEQUENCE
{
eventEnrollmentName [0] ObjectName,
eventConditionTransitions [1] IMPLICIT Transitions OPTIONAL,
alarmAcknowledgmentRule [2] IMPLICIT AlarmAckRule OPTIONAL
}
AlterEventEnrollment-Response ::= SEQUENCE
{
currentState [0] CHOICE
{
state [0] IMPLICIT EE-State,
undefined [1] IMPLICIT NULL
},
transitionTime [1] EventTime
}
AcknowledgeEventNotification-Request ::= SEQUENCE
{
eventEnrollmentName [0] ObjectName,
acknowledgedState [2] IMPLICIT EC-State,
timeOfAcknowledgedTransition [3] EventTime
}
AcknowledgeEventNotification-Response ::= NULL
GetAlarmSummary-Request ::= SEQUENCE
{
enrollmentsOnly [0] IMPLICIT BOOLEAN DEFAULT TRUE,
activeAlarmsOnly [1] IMPLICIT BOOLEAN DEFAULT TRUE,
acknowledgmentFilter [2] IMPLICIT INTEGER
{
not-acked (0),
acked (1),
all (2)
} DEFAULT not-acked,
severityFilter [3] IMPLICIT SEQUENCE
{
mostSevere [0] IMPLICIT Unsigned8,
leastSevere [1] IMPLICIT Unsigned8
} DEFAULT {mostSevere 0, leastSevere 127},
continueAfter [5] ObjectName OPTIONAL
}
GetAlarmSummary-Response ::= SEQUENCE
{
listOfAlarmSummary [0] IMPLICIT SEQUENCE OF AlarmSummary,
moreFollows [1] IMPLICIT BOOLEAN DEFAULT FALSE
}
AlarmSummary ::= SEQUENCE
{
eventConditionName [0] ObjectName,
severity [1] IMPLICIT Unsigned8,
currentState [2] IMPLICIT EC-State,
unacknowledgedState [3] IMPLICIT INTEGER
{
none (0),
active (1),
idle (2),
both (3)
},
timeOfLastTransitionToActive [5] EventTime OPTIONAL,
timeOfLastTransitionToIdle [6] EventTime OPTIONAL
}
GetAlarmEnrollmentSummary-Request ::= SEQUENCE
{
enrollmentsOnly [0] IMPLICIT BOOLEAN DEFAULT TRUE,
activeAlarmsOnly [1] IMPLICIT BOOLEAN DEFAULT TRUE,
acknowledgmentFilter [2] IMPLICIT INTEGER
{
not-acked (0),
acked (1),
all (2)
} DEFAULT not-acked,
severityFilter [3] IMPLICIT SEQUENCE
{
mostSevere [0] IMPLICIT Unsigned8,
leastSevere [1] IMPLICIT Unsigned8
} DEFAULT {mostSevere 0, leastSevere 127},
continueAfter [5] ObjectName OPTIONAL
}
GetAlarmEnrollmentSummary-Response ::= SEQUENCE
{
listOfAlarmEnrollmentSummary [0] IMPLICIT SEQUENCE OF AlarmEnrollmentSummary,
moreFollows [1] IMPLICIT BOOLEAN DEFAULT FALSE
}
AlarmEnrollmentSummary ::= SEQUENCE
{
eventEnrollmentName [0] ObjectName,
clientApplication [2] ApplicationReference OPTIONAL,
severity [3] IMPLICIT Unsigned8,
currentState [4] IMPLICIT EC-State,
notificationLost [6] IMPLICIT BOOLEAN DEFAULT FALSE,
alarmAcknowledgmentRule [7] IMPLICIT AlarmAckRule OPTIONAL,
enrollementState [8] IMPLICIT EE-State OPTIONAL,
timeOfLastTransitionToActive [9] EventTime OPTIONAL,
timeActiveAcknowledged [10] EventTime OPTIONAL,
timeOfLastTransitionToIdle [11] EventTime OPTIONAL,
timeIdleAcknowledged [12] EventTime OPTIONAL
}
EventNotification ::= SEQUENCE
{
eventEnrollmentName [0] ObjectName,
eventConditionName [1] CHOICE
{
eventCondition [0] ObjectName,
undefined [1] IMPLICIT NULL
},
severity [2] IMPLICIT Unsigned8,
currentState [3] IMPLICIT EC-State OPTIONAL,
transitionTime [4] EventTime,
notificationLost [6] IMPLICIT BOOLEAN DEFAULT FALSE,
alarmAcknowledgmentRule [7] IMPLICIT AlarmAckRule OPTIONAL,
actionResult [8] IMPLICIT SEQUENCE
{
eventActioName ObjectName,
eventActionResult CHOICE
{
success [0] ConfirmedServiceResponse,
failure [1] IMPLICIT ServiceError
}
} OPTIONAL
}
AttachToEventCondition ::= SEQUENCE
{
eventEnrollmentName [0] ObjectName,
eventConditionName [1] ObjectName,
causingTransitions [2] IMPLICIT Transitions,
acceptableDelay [3] IMPLICIT Unsigned32 OPTIONAL
}
EventTime ::= CHOICE
{
timeOfDayT [0] IMPLICIT TimeOfDay,
timeSequenceIdentifier [1] IMPLICIT Unsigned32
}
EC-Class ::= INTEGER
{
network-triggered (0),
monitored (1)
}
EC-State ::= INTEGER
{
disabled (0),
idle (1),
active (2)
}
EE-State ::= INTEGER
{
disabled (0),
idle (1),
active (2),
activeNoAckA (3),
idleNoAckI (4),
idleNoAckA (5),
idleAcked (6),
activeAcked (7)
}
Transitions ::= BIT STRING
{
idle-to-disabled (0),
active-to-disabled (1),
disabled-to-idle (2),
active-to-idle (3),
disabled-to-active (4),
idle-to-active (5),
any-to-deleted (6)
}
AlarmAckRule ::= INTEGER
{
none (0),
simple (1),
ack-active (2),
ack-all (3)
}
EE-Class ::= INTEGER
{
modifier (0),
notification (1)
}
EE-Duration ::= INTEGER
{
current (0),
permanent (1)
}
-- ********************************** JOURNAL *******************************************
---------------------------------- READ JOURNAL ----------------------------------
ReadJournal-Request ::= SEQUENCE
{
journalName [0] ObjectName,
rangeStartSpecification [1] CHOICE
{
startingTime [0] IMPLICIT TimeOfDay,
startingEntry [1] IMPLICIT OCTET STRING
} OPTIONAL,
rangeStopSpecification [2] CHOICE
{
endingTime [0] IMPLICIT TimeOfDay,
numberOfEntries [1] IMPLICIT Integer32
} OPTIONAL,
listOfVariables [4] IMPLICIT SEQUENCE OF VisibleString OPTIONAL,
entryToStartAfter [5] IMPLICIT SEQUENCE
{
timeSpecification [0] IMPLICIT TimeOfDay,
entrySpecification [1] IMPLICIT OCTET STRING
}
}
ReadJournal-Response ::= SEQUENCE
{
listOfJournalEntry [0] IMPLICIT SEQUENCE OF JournalEntry,
moreFollows [1] IMPLICIT BOOLEAN DEFAULT FALSE
}
JournalEntry ::= SEQUENCE
{
entryIdentifier [0] IMPLICIT OCTET STRING,
originatingApplication [1] ApplicationReference,
entryContent [2] IMPLICIT EntryContent
}
---------------------------------- WRITE JOURNAL ----------------------------------
WriteJournal-Request ::= SEQUENCE
{
journalName [0] ObjectName,
listOfJournalEntry [1] IMPLICIT SEQUENCE OF EntryContent
}
WriteJournal-Response ::= NULL
-------------------------------- INITIALIZE JOURNAL ----------------------------------
InitializeJournal-Request ::= SEQUENCE
{
journalName [0] ObjectName,
limitSpecification [1] IMPLICIT SEQUENCE
{
limitingTime [0] IMPLICIT TimeOfDay,
limitingEntry [1] IMPLICIT OCTET STRING OPTIONAL
} OPTIONAL
}
InitializeJournal-Response ::= Unsigned32 -- entries deleted
---------------------------------- REPORT JOURNAL STATUS -----------------------------
ReportJournalStatus-Request ::= ObjectName -- Journal Name
ReportJournalStatus-Response ::= SEQUENCE
{
currentEntries [0] IMPLICIT Unsigned32,
mmsDeletable [1] IMPLICIT BOOLEAN
}
---------------------------------- CREATE JOURNAL ----------------------------------
CreateJournal-Request ::= SEQUENCE
{
journalName [0] ObjectName
}
CreateJournal-Response ::= NULL
---------------------------------- DELETE JOURNAL ----------------------------------
DeleteJournal-Request ::= SEQUENCE
{
journalName [0] ObjectName
}
DeleteJournal-Response ::= NULL
-------------------------------- SUPPORTING PRODUCTIONS ----------------------------
EntryContent ::= SEQUENCE
{
occurenceTime [0] IMPLICIT TimeOfDay,
additionalDetail [1] JOU-Additional-Detail OPTIONAL,
-- additionalDetail shall be omitted
-- from abstract syntax defined in this standard
entryForm CHOICE
{
data [2] IMPLICIT SEQUENCE
{
event [0] IMPLICIT SEQUENCE
{
eventConditionName [0] ObjectName,
currentState [1] IMPLICIT EC-State
} OPTIONAL,
listOfVariables [1] IMPLICIT SEQUENCE OF SEQUENCE
{
variableTag [0] IMPLICIT VisibleString,
valueSpecification [1] Data
} OPTIONAL
},
annotation [3] IMPLICIT VisibleString
}
}
JOU-Additional-Detail ::= NULL -- Defined by Companion Standard
-- **************************************** FILES *********************************************
ObtainFile-Request ::= SEQUENCE {
sourceFileServer [0] IMPLICIT ApplicationReference OPTIONAL,
sourceFile [1] IMPLICIT FileName,
destinationFile [2] IMPLICIT FileName
}
ObtainFile-Response ::= NULL
ObtainFile-Error ::= INTEGER {
source-file (0),
destination-file (1)
}
FileOpen-Request ::= SEQUENCE {
fileName [0] IMPLICIT FileName,
initialPosition [1] IMPLICIT Unsigned32
}
FileOpen-Response ::= SEQUENCE {
frsmID [0] IMPLICIT Integer32,
fileAttributes [1] IMPLICIT FileAttributes
}
FileRead-Request ::= Integer32
FileRead-Response ::= SEQUENCE {
fileData [0] IMPLICIT OCTET STRING,
moreFollows [1] IMPLICIT BOOLEAN DEFAULT TRUE
}
FileClose-Request ::= Integer32
FileClose-Response ::= NULL
FileRename-Request ::= SEQUENCE {
currentFileName [0] IMPLICIT FileName,
newFileName [1] IMPLICIT FileName
}
FileRename-Response ::= NULL
FileRename-Error ::= INTEGER {
source-file (0),
destination-file (1)
}
FileDelete-Request ::= FileName
FileDelete-Response ::= NULL
FileDirectory-Request ::= SEQUENCE {
fileSpecification [0] IMPLICIT FileName OPTIONAL,
continueAfter [1] IMPLICIT FileName OPTIONAL
}
FileDirectory-Response ::= SEQUENCE {
listOfDirectoryEntry [0] SEQUENCE OF DirectoryEntry,
moreFollows [1] IMPLICIT BOOLEAN DEFAULT FALSE
}
DirectoryEntry ::= SEQUENCE {
filename [0] IMPLICIT FileName,
fileAttributes [1] IMPLICIT FileAttributes
}
FileAttributes ::= SEQUENCE {
sizeOfFile [0] IMPLICIT Unsigned32,
lastModified [1] IMPLICIT GeneralizedTime OPTIONAL
}
END
扫一扫
337
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
