std.hl7.core

MLLP-Foundation und MSH/ACK-Engine — das Fundament aller std.hl7.*-Units. Implementiert den MLLP-TCP-Framing-Protokoll (VT+Nachricht+FS+CR), den MSH-Segment-Parser, ACK-Erzeugung, versionsübergreifende Validierung und partnerbasierte Duplikatserkennung per FNV1a-Hash.

Alle anderen HL7-Units importieren std.hl7.core und setzen die hier definierten Konstanten und Structs voraus.

import std.hl7.core;
import std.alloc;

// State für Duplikatserkennung allozieren und initialisieren
var state: int64 := alloc(HL7_STATE_SIZE);
Hl7StateInit(state);

// Eingehende MLLP-Nachricht aus TCP-Puffer extrahieren
var tcpBuf:  int64 := alloc(8192);
var msgBuf:  int64 := alloc(8192);
var msgLen:  int64 := MllpFrameRead(tcpBuf, tcpBufLen, msgBuf, 8192);

// MSH parsen
var msh: int64 := alloc(HL7_MSH_SIZE);
var rc:  int64 := Hl7MshParse(msgBuf, msgLen, msh);

// ACK senden
var ackBuf: int64 := alloc(512);
var ackLen: int64 := Hl7AckWrite(msh, "AA"c as int64, "OK"c as int64, ackBuf, 512);

// MLLP-Frame ums ACK legen
var outBuf: int64 := alloc(600);
var outLen: int64 := MllpFrameWrite(outBuf, 600, ackBuf, ackLen);
// outBuf an Socket senden ...

• std.alloc

Alle Structs werden vom Caller alloziert. Größenkonstanten geben die benötigte Byte-Anzahl an.

Jedes Feld wird als Zeiger+Länge-Paar gespeichert (je 8 Bytes). Alle Zeiger weisen in den Originalnachrichtenpuffer (Zero-Copy).

Speichert pro Partner (max. HL7_MAX_PARTNERS = 16) einen Ring-Buffer mit HL7_DUP_RING = 64 FNV1a-Hashes der Kontroll-IDs zur Duplikatserkennung.

import std.hl7.core;
import std.alloc;

fn processHL7Message(tcpBuf: int64, tcpLen: int64, state: int64, sockFd: int64) {
    var msgBuf: int64 := alloc(65536);
    var msgLen: int64 := MllpFrameRead(tcpBuf, tcpLen, msgBuf, 65536);
    if (msgLen < 0) {
        free(msgBuf, 65536);
        return;
    }

    var msh: int64 := alloc(HL7_MSH_SIZE);
    if (Hl7MshParse(msgBuf, msgLen, msh) != HL7_OK) {
        free(msh, HL7_MSH_SIZE);
        free(msgBuf, 65536);
        return;
    }

    // Versionsprüfung
    if (Hl7VersionCheck(msh) != HL7_OK) {
        var ackBuf: int64 := alloc(512);
        var ackLen: int64 := Hl7AckWrite(msh, "AR"c as int64,
            "Unsupported HL7 version"c as int64, ackBuf, 512);
        var outBuf: int64 := alloc(600);
        var outLen: int64 := MllpFrameWrite(outBuf, 600, ackBuf, ackLen);
        // TcpWrite(sockFd, outBuf, outLen);
        free(outBuf, 600);
        free(ackBuf, 512);
        free(msh, HL7_MSH_SIZE);
        free(msgBuf, 65536);
        return;
    }

    // Testnachricht abfangen
    if (Hl7IsTestMsg(msh) == 1) {
        // Logging, aber nicht in Produktions-DB schreiben
    }

    // Duplikatsprüfung (partnerKey = Hash der Absenderkennung)
    var ctrlId: int64 := peek64(msh + HL7_MSH_CTRL_ID);
    if (Hl7DupCheck(state, 1234, ctrlId) == 1) {
        // Duplikat — ACK AA trotzdem senden (Sender erwartet Quittung)
    }

    // Normale Verarbeitung ...
    var ackBuf: int64 := alloc(512);
    var ackLen: int64 := Hl7AckWrite(msh, "AA"c as int64, "OK"c as int64, ackBuf, 512);
    var outBuf: int64 := alloc(600);
    MllpFrameWrite(outBuf, 600, ackBuf, ackLen);

    free(outBuf, 600);
    free(ackBuf, 512);
    free(msh, HL7_MSH_SIZE);
    free(msgBuf, 65536);
}

• Zero-Copy-Parsing: Hl7MshParse setzt alle Zeiger im MSH-Struct direkt in den Originalnachrichtenpuffer — keine Kopien. Der Puffer muss bis zur letzten Verwendung des MSH-Structs gültig bleiben.
• Caller alloziert: Alle Structs (MSH, State) werden vom Caller alloziert. Die Größenkonstanten (HL7_*_SIZE) geben die benötigte Byte-Anzahl an.
• Standard-Zeichensatz: HL7 v2 verwendet standardmäßig ISO-8859-1, nicht UTF-8. Hl7IsUtf8 prüft MSH-18 auf das „UNICODE„-Präfix — nur dann ist UTF-8 zulässig.
• Testnachrichten: Hl7IsTestMsg erkennt MSH-11 = 'T'. Testnachrichten müssen quittiert werden, dürfen aber nicht in Produktionsdatenbanken geschrieben werden.
• Duplikatserkennung: Ring-Buffer mit 64 Einträgen pro Partner. Bei mehr als 64 unterschiedlichen Kontroll-IDs pro Partner kann eine alte ID erneut als „neu“ erscheinen.
• ACK-Sequenz: Der MLLP-Standard erfordert immer eine ACK-Antwort, auch bei Fehlern (AE/AR). Fehlende ACKs führen beim Sender zu Timeouts und Wiederholungsversuchen.

Letzte Aktualisierung: 2026-06-16