[comment]: # ({5ed66e47-9153def3})
# 6 Encabezado

[comment]: # ({/5ed66e47-9153def3})

[comment]: # ({4fd5942c-faa3c87b})
#### Descripción general

La cabecera está presente en todos los mensajes de solicitud y respuesta entre los componentes de Zabbix.
Es necesaria para determinar la longitud del mensaje, si está comprimido o no, y si es un paquete grande o no.

El protocolo de comunicación de Zabbix tiene un límite de tamaño de paquete de 1GB por conexión. El límite de 1GB
se aplica tanto a la longitud de los datos del paquete recibido como a la longitud de los datos descomprimidos.

Al enviar la configuración al proxy de Zabbix, el límite de tamaño de paquete se incrementa a 4GB para permitir
la sincronización de configuraciones grandes. Cuando la longitud de los datos antes de la compresión supera los 4GB, el servidor Zabbix
comienza automáticamente a usar el formato de paquete grande (bandera 0x04), lo que incrementa el límite de tamaño de paquete a 16GB.

Tenga en cuenta que, aunque se puede usar el formato de paquete grande para enviar cualquier dato, actualmente solo el sincronizador de configuración del proxy de Zabbix
puede manejar paquetes que sean mayores de 1GB.

[comment]: # ({/4fd5942c-faa3c87b})

[comment]: # ({40e74a00-409c40cc})
#### Estructura

La cabecera consta de cuatro campos. Todos los números en la cabecera están formateados como little-endian.

|Campo|Tamaño|Tamaño<br>(paquete grande)|Descripción|
|--|-|-|------|
|`<PROTOCOL>`|4|4|`"ZBXD"` o `5A 42 58 44`|
|`<FLAGS>`|1|1|Banderas del protocolo:<br>`0x01` - Protocolo de comunicaciones Zabbix<br>`0x02` - compresión<br>`0x04` - paquete grande|
|`<DATALEN>`|4|8|Longitud de los datos.|
|`<RESERVED>`|4|8|Cuando se utiliza compresión (bandera `0x02`) - la longitud de los datos descomprimidos<br>Cuando no se utiliza compresión - `00 00 00 00`|

[comment]: # ({/40e74a00-409c40cc})

[comment]: # ({bb53a69e-8698de59})
#### Ejemplos

Aquí hay algunos fragmentos de código que muestran cómo agregar la cabecera del protocolo Zabbix a los datos que desea enviar para 
obtener el paquete que debe enviar a Zabbix para que se interprete correctamente. Estos fragmentos de código 
suponen que los datos no son mayores de 1GB, por lo que no se utiliza el formato de paquete grande.

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

o

```python
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

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

o

```perl
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

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

o

```php
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
  
```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"
```

[comment]: # ({/bb53a69e-8698de59})