Documentation

Table of Contents

4 Header
- Overzicht
- Structuur
- Voorbeelden
  - Python
  - Perl
  - PHP
  - Bash

Overzicht

De header is aanwezig in alle verzoek- en antwoordberichten tussen Zabbix-componenten. Het is nodig om de lengte van het bericht te bepalen, of het gecomprimeerd is of niet, of het een groot pakket is of niet.

Het Zabbix-communicatieprotocol heeft een limiet van 1 GB per pakket per verbinding. De limiet van 1 GB is van toepassing op zowel de ontvangen pakketgegevenslengte als de lengte van de ongecomprimeerde gegevens.

Bij het verzenden van configuratie naar een Zabbix-proxy wordt de pakketgroottegrens verhoogd naar 4 GB om het synchroniseren van grote configuraties mogelijk te maken. Wanneer de lengte van de gegevens vóór compressie de 4 GB overschrijdt, begint de Zabbix-server automatisch het grote pakketformaat (0x04-vlag) te gebruiken, waardoor de pakketgroottegrens wordt verhoogd naar 16 GB.

Merk op dat hoewel een groot pakketformaat kan worden gebruikt om alle gegevens te verzenden, momenteel alleen de Zabbix-proxyconfiguratiesynchronisator pakketten kan verwerken die groter zijn dan 1 GB.

Structuur

De header bestaat uit vier velden. Alle getallen in de header zijn opgemaakt als little-endian.

Veld	Grootte	Grootte (groot pakket)	Beschrijving
`<PROTOCOL>`	4	4	`"ZBXD"` of `5A 42 58 44`
`<FLAGS>`	1	1	Protocolvlaggen: `0x01` - Zabbix-communicatieprotocol `0x02` - compressie `0x04` - groot pakket
`<DATALEN>`	4	8	Gegevenslengte.
`<GERESERVEERD>`	4	8	Bij gebruik van compressie (`0x02`-vlag) - de lengte van ongecomprimeerde gegevens Bij geen gebruik van compressie - `00 00 00 00`

Voorbeelden

Hier zijn enkele codefragmenten die laten zien hoe je een Zabbix-protocolheader kunt toevoegen aan de gegevens die je wilt verzenden om het pakket te verkrijgen dat je naar Zabbix moet sturen zodat het correct wordt geïnterpreteerd. Deze codefragmenten gaan ervan uit dat de gegevens niet groter zijn dan 1 GB, dus het grote pakketformaat wordt niet gebruikt.

Python

packet = b"ZBXD\1" + struct.pack("<II", len(data), 0) + data

of

def zbx_create_header(plain_data_size, compressed_data_size=None):
           protocol = b"ZBXD"
           flags = 0x01
           if compressed_data_size is None:
               datalen = plain_data_size
               reserved = 0
           else:
               flags |= 0x02
               datalen = compressed_data_size
               reserved = plain_data_size
           return protocol + struct.pack("<BII", flags, datalen, reserved)
       
       packet = zbx_create_header(len(data)) + data

Perl

my $packet = "ZBXD\1" . pack("(II)<", length($data), 0) . $data;

of

sub zbx_create_header($;$)
       {
           my $plain_data_size = shift;
           my $compressed_data_size = shift;
       
           my $protocol = "ZBXD";
           my $flags = 0x01;
           my $datalen;
           my $reserved;
       
           if (!defined($compressed_data_size))
           {
               $datalen = $plain_data_size;
               $reserved = 0;
           }
           else
           {
               $flags |= 0x02;
               $datalen = $compressed_data_size;
               $reserved = $plain_data_size;
           }
       
           return $protocol . chr($flags) . pack("(II)<", $datalen, $reserved);
       }
       
       my $packet = zbx_create_header(length($data)) . $data;

PHP

$packet = "ZBXD\1" . pack("VV", strlen($data), 0) . $data;

of

function zbx_create_header($plain_data_size, $compressed_data_size = null)
       {
           $protocol = "ZBXD";
           $flags = 0x01;
           if (is_null($compressed_data_size))
           {
               $datalen = $plain_data_size;
               $reserved = 0;
           }
           else
           {
               $flags |= 0x02;
               $datalen = $compressed_data_size;
               $reserved = $plain_data_size;
           }
           return $protocol . chr($flags) . pack("VV", $datalen, $reserved);
       }
       
       $packet = zbx_create_header(strlen($data)) . $data;

Bash

datalen=$(printf "%08x" ${#data})
       datalen="\\x${datalen:6:2}\\x${datalen:4:2}\\x${datalen:2:2}\\x${datalen:0:2}"
       printf "ZBXD\1${datalen}\0\0\0\0%s" "$data"