Da ideia à implementação

Gostaria de apresentar a vocês minha ideia e como surgiu a ideia de dar uma ligação ao “ROHC” no NodeJS.

Eu queria implementar uma VPN que rodasse em Web-Socket. As vantagens seriam que o serviço ficaria oculto em HTTPS. Com HTTP3 isso seria ainda mais otimizado. Então comecei a brincar com o módulo TunTap2 para NodeJS, que tive que corrigir primeiro.

Sempre fascinado pela tecnologia wireless, em algum momento me deparei com “LoRa” e com ele um projeto “IP2Lora”.

Fonte da imagem

Neste projeto “IP2Lora”, os pacotes IP foram encurtados para economizar 40 bytes, o que é muito importante para a transferência; com uma banda de rádio de 434 MHz ou 868 MHz, pouco pode ser transferido.

Fonte da imagem

No gráfico você pode ver claramente como o tamanho do pacote IP diminui.

Infelizmente, havia apenas uma ligação de lib para Python.

Então por que não escrever uma biblioteca de nó vinculando você mesmo!?

O resultado agora pode ser visto.
https://www.npmjs.com/package/node-rohc

Você pode saber mais sobre como funciona o ROHC nos links do projeto ou simplesmente pesquisá-lo. Não vou explicar aqui para não deixar o post muito longo.

Biblioteca de instalação

Eu instalei no Linux Debian/Mint. Acho que isso deve ser semelhante a outras versões do Linux.

(A propósito, eu também tive que corrigir o ROHC-lib para o novo kernel.)

sudo apt-get install autotools-dev
sudo apt-get install automake
sudo apt-get install libtool
sudo apt-get install libpcap-dev
sudo apt-get install -y libcmocka-dev

git clone https://github.com/stefanwerfling/rohc.git
cd rohc

./autogen.sh --prefix=/usr

make all
sudo make install

Instalação NPM

Agora podemos entrar em nosso projeto e instalar o módulo.

cd yourProject
npm i node-rohc

Agora temos que criar a ligação NodeJS (isso deve ser compilado para cada arquitetura de CPU).

cd yourProject/node_modules/node-rohc
npm run build --loglevel verbose

A instalação está agora completa.

Codificação/uso de API

Agora vamos supor que recebemos um pacote IP que queremos compactar nos seguintes pacotes para economizar bytes.

const ipU8Packet = new Uint8Array(ipPacketBufferWithContent);
console.log(ipU8Packet);

Uint8Array(52) [
   69,   0,   0,  52,   0,   0,   0,   0,  64,  6, 249,
  112, 192, 168,   0,   1, 192, 168,   0,   2, 72, 101,
  108, 108, 111,  44,  32, 116, 104, 105, 115, 32, 105,
  115,  32, 116, 104, 101,  32, 100,  97, 116, 97,  32,
  112,  97, 121, 108, 111,  97, 100,  33
]

O módulo agora é importado e o Unit8Array no qual o pacote IP é entregue ao objeto Rhoc para compactação.

import {Rohc} from 'node-rohc';

const r = new Rohc([
  RohcProfiles.ROHC_PROFILE_UNCOMPRESSED,
  RohcProfiles.ROHC_PROFILE_IP,
  RohcProfiles.ROHC_PROFILE_TCP,
  RohcProfiles.ROHC_PROFILE_UDP,
  RohcProfiles.ROHC_PROFILE_ESP,
  RohcProfiles.ROHC_PROFILE_RTP
]);

try {
    const compress = r.compress(ipU8Packet);
    console.log(compress);
} catch (e) {
    console.error(e);
}

Uint8Array(53) [
  253,   4,  69,  64,   6, 192, 168,   0,   1, 192, 168,
    0,   2,   0,  64,   0,   0,  32,   0, 251, 103,  72,
  101, 108, 108, 111,  44,  32, 116, 104, 105, 115,  32,
  105, 115,  32, 116, 104, 101,  32, 100,  97, 116,  97,
   32, 112,  97, 121, 108, 111,  97, 100,  33
]

No construtor do objeto Rohc especificamos os perfis que devem ser usados ​​para compactação em um array.

Depois vem a compressão. Na saída vemos o novo pacote. Mas por que não é menor?

O primeiro pacote ainda contém as informações sobre porta/endereço IP, etc. Apenas os pacotes seguintes se tornam significativamente menores.

Para converter o pacote Rohc de volta em um pacote IP normal, usamos descompactar.

try {
    const decompress = r.decompress(compress);
    console.log(decompress);
} catch (e) {
    console.error(e);
}

Uint8Array(52) [
   69,   0,   0,  52,   0,   0,   0,   0,  64,  6, 249,
  112, 192, 168,   0,   1, 192, 168,   0,   2, 72, 101,
  108, 108, 111,  44,  32, 116, 104, 105, 115, 32, 105,
  115,  32, 116, 104, 101,  32, 100,  97, 116, 97,  32,
  112,  97, 121, 108, 111,  97, 100,  33
]

O que importa é o início, o primeiro pacote é compactado e transmitido ao destino e o destino descompactou o pacote, a instância deve ser mantida. Para que o ID da conexão permaneça conhecido. Isso significa que o programa deve manter a instância do objeto em execução. Se uma das duas páginas (origem com compactação ou destino com descompactação) for interrompida, ambas as páginas deverão ser reiniciadas.

Função adicional com informações úteis:

Último status de compactação/descompactação

import {Rohc, RohcStatus} from 'node-rohc';

    if (r.getLastStatus() === RohcStatus.ROHC_OK) {
      console.log('All OK');
    }

Durante a compactação ou descompactação, o status é lembrado; isso pode ser consultado novamente imediatamente depois para obter informações mais detalhadas sobre o que aconteceu.

Informações do último pacote compactado/descompactado

console.log(r.compressLastPacketInfo());
console.log(r.decompressLastPacketInfo());

{
  version_major: 0,
  version_minor: 0,
  context_id: 0,
  is_context_init: true,
  context_mode: 1,
  context_state: 1,
  context_used: true,
  profile_id: 4,
  packet_type: 0,
  total_last_uncomp_size: 52,
  header_last_uncomp_size: 20,
  total_last_comp_size: 53,
  header_last_comp_size: 21
}
{
  version_major: 0,
  version_minor: 0,
  context_mode: 2,
  context_state: 3,
  profile_id: 4,
  nr_lost_packets: 0,
  nr_misordered_packets: 0,
  is_duplicated: false,
  corrected_crc_failures: 11745388377929038000,
  corrected_sn_wraparounds: 14987979559889062000,
  corrected_wrong_sn_updates: 12105675798372346000,
  packet_type: 449595,
  total_last_comp_size: 18407961667527770000,
  header_last_comp_size: 1940628627783807,
  total_last_uncomp_size: 18407961667125117000,
  header_last_uncomp_size: 217316637802623
}

Informações sobre a última compactação ou descompactação.

Informações gerais de compactação/descompactação

console.log(r.compressGeneralInfo());
console.log(r.decompressGeneralInfo());

{
  version_major: 0,
  version_minor: 0,
  contexts_nr: 1,
  packets_nr: 1,
  uncomp_bytes_nr: 52,
  comp_bytes_nr: 53
}
{
  version_major: 0,
  version_minor: 0,
  contexts_nr: 1,
  packets_nr: 1,
  comp_bytes_nr: 53,
  uncomp_bytes_nr: 52,
  corrected_crc_failures: 0,
  corrected_sn_wraparounds: 8518447232180027000,
  corrected_wrong_sn_updates: 4295000063
}

Informações gerais sobre compactação e descompactação.

Palavra final

Espero que tenham gostado do meu pequeno post. Estou sempre aberto a melhorias.