Zum Hauptinhalt springen

4. Abstract Service Interfaces (Abstrakte Service-Schnittstellen)

4. Abstract Service Interfaces (Abstrakte Service-Schnittstellen)​

Dieser Abschnitt beschreibt die abstrakten Service-Schnittstellen zwischen den Hauptkomponenten der SNMP-Architektur. Diese Schnittstellen werden unter Verwendung abstrakter Primitive definiert, die die Informationen darstellen, die zwischen Komponenten übergeben werden müssen, ohne zu spezifizieren, wie sie übergeben werden.

Die abstrakten Service-Schnittstellen sind in mehrere Kategorien organisiert:

  • Dispatcher-Primitive: Schnittstellen zwischen Anwendungen und dem Dispatcher
  • Message Processing Subsystem-Primitive: Schnittstellen zwischen dem Dispatcher und Message Processing Models
  • Access Control Subsystem-Primitive: Schnittstellen zwischen Anwendungen und dem Access Control Subsystem
  • Security Subsystem-Primitive: Schnittstellen zwischen Message Processing Models und Security Models

4.1. Dispatcher Primitives (Dispatcher-Primitive)​

Der Dispatcher bietet Anwendungen Dienste zum Senden und Empfangen von SNMP-Nachrichten. Er fungiert als zentraler Punkt für das Routing von Nachrichten und PDUs.

4.1.1. Generate Outgoing Request or Notification (Ausgehende Anfrage oder Benachrichtigung generieren)​

Anwendungen verwenden das sendPdu-Primitiv, um vom Dispatcher zu verlangen, eine SNMP-Nachricht mit einer PDU zu senden.

Primitiv:

statusInformation =
  sendPdu(
    IN  transportDomain
    IN  transportAddress
    IN  messageProcessingModel
    IN  securityModel
    IN  securityName
    IN  securityLevel
    IN  contextEngineID
    IN  contextName
    IN  pduVersion
    IN  PDU
    IN  expectResponse
    IN  sendPduHandle
    OUT destTransportDomain
    OUT destTransportAddress
  )

Parameter:

  • transportDomain: Das zu verwendende Transportprotokoll (z.B. UDP)
  • transportAddress: Die Zieladresse
  • messageProcessingModel: Das zu verwendende Nachrichtenformat
  • securityModel: Das zu verwendende Sicherheitsmodell
  • securityName: Der Principal, in dessen Namen die Nachricht gesendet wird
  • securityLevel: Das Sicherheitsniveau (noAuthNoPriv, authNoPriv oder authPriv)
  • contextEngineID: Die Context-Engine-ID
  • contextName: Der Context-Name
  • pduVersion: Die PDU-Version
  • PDU: Die zu sendende PDU
  • expectResponse: Ob eine Antwort erwartet wird
  • sendPduHandle: Ein Handle zur Identifizierung dieser Anfrage
  • destTransportDomain: (OUT) Die tatsächlich verwendete Transport-Domain
  • destTransportAddress: (OUT) Die tatsächlich verwendete Transport-Adresse
  • statusInformation: (OUT) Erfolgs- oder Fehleranzeige

4.1.2. Process Incoming Request or Notification PDU (Eingehende Anfrage oder Benachrichtigungs-PDU verarbeiten)​

Der Dispatcher verwendet das processPdu-Primitiv, um eine eingehende Anfrage- oder Benachrichtigungs-PDU an eine Anwendung zu liefern.

Primitiv:

processPdu(
  IN  messageProcessingModel
  IN  securityModel
  IN  securityName
  IN  securityLevel
  IN  contextEngineID
  IN  contextName
  IN  pduVersion
  IN  PDU
  IN  maxSizeResponseScopedPDU
  IN  stateReference
)

Parameter:

  • messageProcessingModel: Das verwendete Nachrichtenformat
  • securityModel: Das verwendete Sicherheitsmodell
  • securityName: Der Principal, in dessen Namen die Nachricht gesendet wurde
  • securityLevel: Das auf die Nachricht angewendete Sicherheitsniveau
  • contextEngineID: Die Context-Engine-ID
  • contextName: Der Context-Name
  • pduVersion: Die PDU-Version
  • PDU: Die empfangene PDU
  • maxSizeResponseScopedPDU: Die maximale Größe für eine Antwort
  • stateReference: Verweis auf zwischengespeicherte Zustandsinformationen

4.1.3. Generate Outgoing Response (Ausgehende Antwort generieren)​

Anwendungen verwenden das returnResponsePdu-Primitiv, um vom Dispatcher zu verlangen, eine Antwortnachricht zu senden.

Primitiv:

result =
  returnResponsePdu(
    IN  messageProcessingModel
    IN  securityModel
    IN  securityName
    IN  securityLevel
    IN  contextEngineID
    IN  contextName
    IN  pduVersion
    IN  PDU
    IN  maxSizeResponseScopedPDU
    IN  stateReference
    IN  statusInformation
  )

Parameter:

  • messageProcessingModel: Das zu verwendende Nachrichtenformat (von processPdu)
  • securityModel: Das zu verwendende Sicherheitsmodell (von processPdu)
  • securityName: Der Principal (von processPdu)
  • securityLevel: Das Sicherheitsniveau (von processPdu)
  • contextEngineID: Die Context-Engine-ID (von processPdu)
  • contextName: Der Context-Name (von processPdu)
  • pduVersion: Die PDU-Version (von processPdu)
  • PDU: Die zu sendende Antwort-PDU
  • maxSizeResponseScopedPDU: Maximale Größe für die Antwort (von processPdu)
  • stateReference: Zustandsinformationen (von processPdu)
  • statusInformation: Statusinformationen über die Verarbeitung der Anfrage
  • result: (OUT) Erfolgs- oder Fehleranzeige

4.1.4. Process Incoming Response PDU (Eingehende Antwort-PDU verarbeiten)​

Der Dispatcher verwendet das processResponsePdu-Primitiv, um eine Antwort-PDU an eine Anwendung zu liefern.

Primitiv:

processResponsePdu(
  IN  messageProcessingModel
  IN  securityModel
  IN  securityName
  IN  securityLevel
  IN  contextEngineID
  IN  contextName
  IN  pduVersion
  IN  PDU
  IN  statusInformation
  IN  sendPduHandle
)

Parameter:

  • messageProcessingModel: Das verwendete Nachrichtenformat
  • securityModel: Das verwendete Sicherheitsmodell
  • securityName: Der Principal
  • securityLevel: Das angewendete Sicherheitsniveau
  • contextEngineID: Die Context-Engine-ID
  • contextName: Der Context-Name
  • pduVersion: Die PDU-Version
  • PDU: Die empfangene Antwort-PDU
  • statusInformation: Statusinformationen über die Nachrichtenverarbeitung
  • sendPduHandle: Das Handle aus der ursprünglichen sendPdu-Anfrage

4.1.5. Registering Responsibility for Handling SNMP PDUs (Registrierung der Verantwortlichkeit für die Behandlung von SNMP-PDUs)​

Anwendungen müssen sich beim Dispatcher registrieren, um bestimmte Arten von PDUs zu empfangen.

Primitiv für Registrierung:

statusInformation =
  registerContextEngineID(
    IN  contextEngineID
    IN  pduType
  )

Primitiv für Deregistrierung:

unregisterContextEngineID(
  IN  contextEngineID
  IN  pduType
)

Parameter:

  • contextEngineID: Die zu registrierende Context-Engine-ID
  • pduType: Der Typ der zu empfangenden PDU (Get, GetNext, GetBulk, Set, Trap, InformRequest usw.)
  • statusInformation: (OUT) Erfolgs- oder Fehleranzeige

Nur eine Anwendung kann sich gleichzeitig für eine bestimmte Kombination aus contextEngineID und pduType registrieren.

4.2. Message Processing Subsystem Primitives (Message Processing Subsystem-Primitive)​

Das Message Processing Subsystem bietet dem Dispatcher Dienste zur Vorbereitung von Nachrichten und zur Extraktion von Daten aus Nachrichten.

4.2.1. Prepare Outgoing SNMP Request or Notification Message (Ausgehende SNMP-Anfrage oder Benachrichtigungsnachricht vorbereiten)​

Der Dispatcher verwendet das prepareOutgoingMessage-Primitiv, um von einem Message Processing Model zu verlangen, eine Nachricht für die Übertragung vorzubereiten.

Primitiv:

statusInformation =
  prepareOutgoingMessage(
    IN  transportDomain
    IN  transportAddress
    IN  messageProcessingModel
    IN  securityModel
    IN  securityName
    IN  securityLevel
    IN  contextEngineID
    IN  contextName
    IN  pduVersion
    IN  PDU
    IN  expectResponse
    IN  sendPduHandle
    OUT destTransportDomain
    OUT destTransportAddress
    OUT outgoingMessage
    OUT outgoingMessageLength
  )

Parameter:

  • Eingabeparameter sind die gleichen wie für sendPdu
  • outgoingMessage: (OUT) Die übertragungsbereite Nachricht
  • outgoingMessageLength: (OUT) Die Länge der Nachricht
  • statusInformation: (OUT) Erfolgs- oder Fehleranzeige

Das Message Processing Model:

  1. Erstellt eine scopedPDU aus contextEngineID, contextName und PDU
  2. Ruft das Security Model auf, um Sicherheitsverarbeitung anzuwenden
  3. Verpackt die gesicherte Nachricht im entsprechenden Nachrichtenformat
  4. Gibt die vollständige übertragungsbereite Nachricht zurück

4.2.2. Prepare an Outgoing SNMP Response Message (Ausgehende SNMP-Antwortnachricht vorbereiten)​

Der Dispatcher verwendet das prepareResponseMessage-Primitiv, um von einem Message Processing Model zu verlangen, eine Antwortnachricht für die Übertragung vorzubereiten.

Primitiv:

result =
  prepareResponseMessage(
    IN  messageProcessingModel
    IN  securityModel
    IN  securityName
    IN  securityLevel
    IN  contextEngineID
    IN  contextName
    IN  pduVersion
    IN  PDU
    IN  maxSizeResponseScopedPDU
    IN  stateReference
    IN  statusInformation
    OUT destTransportDomain
    OUT destTransportAddress
    OUT outgoingMessage
    OUT outgoingMessageLength
  )

Parameter:

  • Eingabeparameter enthalten Zustandsinformationen aus der ursprünglichen Anfrage
  • outgoingMessage: (OUT) Die vorbereitete Antwortnachricht
  • outgoingMessageLength: (OUT) Die Länge der Nachricht
  • result: (OUT) Erfolgs- oder Fehleranzeige

Das Message Processing Model:

  1. Ruft zwischengespeicherte Informationen unter Verwendung der stateReference ab
  2. Erstellt eine scopedPDU aus contextEngineID, contextName und PDU
  3. Ruft das Security Model auf, um Sicherheitsverarbeitung anzuwenden
  4. Verpackt die gesicherte Nachricht im entsprechenden Nachrichtenformat
  5. Gibt die vollständige übertragungsbereite Nachricht zurück
  6. Gibt die zwischengespeicherten Zustandsinformationen frei

4.2.3. Prepare Data Elements from an Incoming SNMP Message (Datenelemente aus einer eingehenden SNMP-Nachricht vorbereiten)​

Der Dispatcher verwendet das prepareDataElements-Primitiv, um von einem Message Processing Model zu verlangen, Daten aus einer empfangenen Nachricht zu extrahieren.

Primitiv:

result =
  prepareDataElements(
    IN  transportDomain
    IN  transportAddress
    IN  wholeMsg
    IN  wholeMsgLength
    OUT messageProcessingModel
    OUT securityModel
    OUT securityName
    OUT securityLevel
    OUT contextEngineID
    OUT contextName
    OUT pduVersion
    OUT PDU
    OUT pduType
    OUT sendPduHandle
    OUT maxSizeResponseScopedPDU
    OUT statusInformation
    OUT stateReference
  )

Parameter:

  • transportDomain: Das Transportprotokoll, über das die Nachricht angekommen ist
  • transportAddress: Die Quelladresse
  • wholeMsg: Die empfangene Nachricht
  • wholeMsgLength: Die Länge der Nachricht
  • Alle OUT-Parameter enthalten die extrahierten Datenelemente
  • result: (OUT) Erfolgs- oder Fehleranzeige

Das Message Processing Model:

  1. Analysiert das Nachrichtenformat
  2. Ruft das Security Model auf, um Sicherheit zu verarbeiten
  3. Extrahiert die scopedPDU
  4. Analysiert die scopedPDU, um contextEngineID, contextName und PDU zu extrahieren
  5. Speichert Zustandsinformationen zwischen, wenn die Nachricht eine Antwort erfordert
  6. Gibt alle extrahierten Datenelemente zurück

4.3. Access Control Subsystem Primitives (Access Control Subsystem-Primitive)​

Das Access Control Subsystem bietet Anwendungen Dienste zur Bestimmung, ob der Zugriff auf ein verwaltetes Objekt erlaubt werden sollte.

Primitiv:

statusInformation =
  isAccessAllowed(
    IN  securityModel
    IN  securityName
    IN  securityLevel
    IN  viewType
    IN  contextName
    IN  variableName
  )

Parameter:

  • securityModel: Das verwendete Sicherheitsmodell
  • securityName: Der Principal, der den Zugriff versucht
  • securityLevel: Das Sicherheitsniveau der Nachricht
  • viewType: Der Zugriffstyp (read, write oder notify)
  • contextName: Der Context, auf den zugegriffen wird
  • variableName: Die OID des verwalteten Objekts
  • statusInformation: (OUT) Erlaubt oder verweigert

Das Access Control Model bestimmt basierend auf seiner konfigurierten Richtlinie, ob die angegebene Operation erlaubt werden sollte.

4.4. Security Subsystem Primitives (Security Subsystem-Primitive)​

Das Security Subsystem bietet Message Processing Models Dienste zur Anwendung und Überprüfung von Sicherheit.

4.4.1. Generate a Request or Notification Message (Anfrage- oder Benachrichtigungsnachricht generieren)​

Message Processing Models verwenden das generateRequestMsg-Primitiv, um vom Security Subsystem zu verlangen, Sicherheitsverarbeitung auf eine ausgehende Anfrage- oder Benachrichtigungsnachricht anzuwenden.

Primitiv:

statusInformation =
  generateRequestMsg(
    IN  messageProcessingModel
    IN  globalData
    IN  maxMessageSize
    IN  securityModel
    IN  securityEngineID
    IN  securityName
    IN  securityLevel
    IN  scopedPDU
    OUT securityParameters
    OUT wholeMsg
    OUT wholeMsgLength
  )

Parameter:

  • messageProcessingModel: Das verwendete Nachrichtenformat
  • globalData: Nachrichtenformat-spezifische Header-Daten
  • maxMessageSize: Unterstützte maximale Nachrichtengröße
  • securityModel: Das zu verwendende Sicherheitsmodell
  • securityEngineID: Die autoritative Engine-ID
  • securityName: Der Principal
  • securityLevel: Das gewünschte Sicherheitsniveau
  • scopedPDU: Die zu sichernde scoped PDU
  • securityParameters: (OUT) Sicherheitsmodell-spezifische Parameter
  • wholeMsg: (OUT) Die vollständig gesicherte Nachricht
  • wholeMsgLength: (OUT) Die Länge der Nachricht
  • statusInformation: (OUT) Erfolgs- oder Fehleranzeige

4.4.2. Process Incoming Message (Eingehende Nachricht verarbeiten)​

Message Processing Models verwenden das processIncomingMsg-Primitiv, um vom Security Subsystem zu verlangen, eine eingehende Nachricht zu verarbeiten.

Primitiv:

statusInformation =
  processIncomingMsg(
    IN  messageProcessingModel
    IN  maxMessageSize
    IN  securityParameters
    IN  securityModel
    IN  securityLevel
    IN  wholeMsg
    IN  wholeMsgLength
    OUT securityEngineID
    OUT securityName
    OUT scopedPDU
    OUT maxSizeResponseScopedPDU
    OUT securityStateReference
  )

Parameter:

  • messageProcessingModel: Das verwendete Nachrichtenformat
  • maxMessageSize: Unterstützte maximale Nachrichtengröße
  • securityParameters: Sicherheitsmodell-spezifische Parameter aus der Nachricht
  • securityModel: Das in der Nachricht angegebene Sicherheitsmodell
  • securityLevel: Das gewünschte Sicherheitsniveau
  • wholeMsg: Die empfangene Nachricht
  • wholeMsgLength: Die Länge der Nachricht
  • securityEngineID: (OUT) Die autoritative Engine-ID
  • securityName: (OUT) Der Principal
  • scopedPDU: (OUT) Die extrahierte und verifizierte scoped PDU
  • maxSizeResponseScopedPDU: (OUT) Maximale Größe für eine Antwort
  • securityStateReference: (OUT) Verweis auf zwischengespeicherten Sicherheitszustand
  • statusInformation: (OUT) Erfolgs- oder Fehleranzeige

Das Security Model:

  1. Überprüft, ob die Nachricht authentisch ist (wenn Authentifizierung erforderlich ist)
  2. Entschlüsselt die Nachricht (wenn Vertraulichkeit erforderlich ist)
  3. Überprüft die Aktualität der Nachricht (um Replay-Angriffe zu verhindern)
  4. Extrahiert die scopedPDU
  5. Speichert Sicherheitszustand zwischen, wenn eine Antwort erforderlich sein könnte
  6. Gibt alle extrahierten Daten zurück

4.4.3. Generate a Response Message (Antwortnachricht generieren)​

Message Processing Models verwenden das generateResponseMsg-Primitiv, um vom Security Subsystem zu verlangen, Sicherheitsverarbeitung auf eine ausgehende Antwortnachricht anzuwenden.

Primitiv:

statusInformation =
  generateResponseMsg(
    IN  messageProcessingModel
    IN  globalData
    IN  maxMessageSize
    IN  securityModel
    IN  securityEngineID
    IN  securityName
    IN  securityLevel
    IN  scopedPDU
    IN  securityStateReference
    OUT securityParameters
    OUT wholeMsg
    OUT wholeMsgLength
  )

Parameter:

  • Ähnlich wie generateRequestMsg, aber enthält securityStateReference
  • securityStateReference: Zwischengespeicherter Zustand aus der ursprünglichen Anfrage
  • Andere Parameter sind ähnlich wie bei generateRequestMsg

Das Security Model verwendet den zwischengespeicherten Sicherheitszustand, um dieselbe Sicherheitsverarbeitung auf die Antwort anzuwenden wie auf die Anfrage.

4.5. Common Primitives (Gemeinsame Primitive)​

4.5.1. Release State Reference Information (Zustandsreferenzinformationen freigeben)​

Komponenten verwenden das stateRelease-Primitiv, um zwischengespeicherte Zustandsinformationen freizugeben.

Primitiv:

stateRelease(
  IN  stateReference
)

Parameter:

  • stateReference: Der Verweis auf den freizugebenden zwischengespeicherten Zustand

Dieses Primitiv wird verwendet, um Ressourcen freizugeben, wenn zwischengespeicherte Zustandsinformationen nicht mehr benötigt werden. Es wird typischerweise aufgerufen, wenn:

  • Eine Antwort gesendet wurde
  • Ein Fehler aufgetreten ist und keine Antwort gesendet wird
  • Ein Timeout beim Warten auf eine Antwort aufgetreten ist

4.6. Scenario Diagrams (Szenariodiagramme)​

Dieser Abschnitt enthält Szenariodiagramme, die den Fluss von Primitiven für allgemeine Operationen zeigen.

4.6.1. Command Generator or Notification Originator (Command Generator oder Notification Originator)​

Das folgende Diagramm zeigt den Ablauf, wenn eine Anwendung eine Anfrage oder Benachrichtigung initiiert:

Application          Dispatcher       Message Processing    Security
                                      Model                 Model

sendPdu ----------->
                     prepareOutgoing
                     Message -------->
                                      generateRequestMsg -->
                                                            (Sicherheit anwenden)
                                      <------------------
                     <--------------
                     (Nachricht ans Netzwerk senden)

(später kommt Antwort)

                     (Nachricht vom Netzwerk empfangen)
                     prepareData
                     Elements ------->
                                      processIncomingMsg -->
                                                            (Sicherheit prüfen)
                                      <------------------
                     <--------------
processResponsePdu <-

4.6.2. Scenario Diagram for a Command Responder Application (Szenariodiagramm für eine Command Responder-Anwendung)​

Das folgende Diagramm zeigt den Ablauf, wenn eine Anwendung auf eine Anfrage antwortet:

Application          Dispatcher       Message Processing    Security
                                      Model                 Model

                     (Nachricht vom Netzwerk empfangen)
                     prepareData
                     Elements ------->
                                      processIncomingMsg -->
                                                            (Sicherheit prüfen)
                                      <------------------
                     <--------------
processPdu <--------

                     (Anwendung verarbeitet Anfrage)

returnResponsePdu ->
                     prepareResponse
                     Message -------->
                                      generateResponseMsg ->
                                                            (Sicherheit anwenden)
                                      <------------------
                     <--------------
                     (Nachricht ans Netzwerk senden)

Diese Diagramme veranschaulichen das modulare Design der Architektur und die klare Trennung der Zuständigkeiten zwischen verschiedenen Subsystemen.

Letztes Update am