Erro "Segmentation fault" ao executar método NFE_DistribuicaoDFePorUltNSU

[leoprates]

Boa Tarde Daniel!
Alterei para 4096 e ainda da o erro abaixo.
Creio que o certificado e a senha estejam sendo corretamente configurados no método "NFE_ConfigGravarValor", uma vez que se eu colocar a senha errada ou o diretório errado do certificado o erro muda.

 

10/10/23 15:52:56:433 -    SetRetorno(-16, WebService Distribuição de DFe:

- Inativo ou Inoperante tente novamente.

Erro Interno: -2

Erro HTTP: 500

URL: https://hom1.nfe.fazenda.gov.br/NFeDistribuicaoDFe/NFeDistribuicaoDFe.asmx

error:140AB18E:SSL routines:func(171):reason(398)

[Renato Rubinho]

Boa tarde,

O XML de retorno pode ser maior ainda, 6, 7, 8k.

Para efeito de testes, tente valores maiores, exemplo 16k e veja se resolve.

Outro teste, tente passar o ultNSU errado, o método vai retornar um XML pequeno e descartamos a hipótese do buffer se permanecer o problema.

[leoprates]

Boa noite Renato! Primeiramente obrigado pelo retorno.

Testei com diferentes valores para o buffer (até 16k) e infelizmente tive o mesmo erro registrado no log.

Efetuei um teste com ultNSU errado e novamente, o mesmo erro.

 

 

[Daniel Simoes]

@antonio.carlos,

Você consegue reproduzir esses testes, com esses métodos, no Demo do ACBr em C#

@leoprates,

Qual versão da DLL você está utilizando ?

[Renato Rubinho]

Em 05/10/2023 at 11:46, leoprates disse:

const aloc_sResposta = Buffer.alloc(BUFF_LENGTH);

Mais uma coisa, a declaração da variável não deveria ser "var", "string", etc?

Em tese uma constante não receberia um retorno.

[antonio.carlos]

10 horas atrás, Daniel Simoes disse:

Você consegue reproduzir esses testes, com esses métodos, no Demo do ACBr em C#

Verificando.. 

[Diego Foliene]

Bom dia!

Realizado teste com o programa exemplo em C# e Dll no ambiente Windows.

 

Citar

11/10/23 11:12:01:402 - NFe_DistribuicaoDFePorUltNSU(35,18760540000139,0)
11/10/23 11:12:01:406 - Travar
11/10/23 11:12:01:410 - NFe_DistribuicaoDFePorUltNSU, Executar
11/10/23 11:12:01:968 - NFe_DistribuicaoDFePorUltNSU, Proces.Resp DistribuicaoDFe
11/10/23 11:12:01:973 -    MoverStringParaPChar. StrLen:253, BufLen:256
11/10/23 11:12:01:978 -    SetRetorno(0, [DistribuicaoDFe]
CStat=137
CUF=0
DhRecbto=
Msg=Nenhum documento localizado
VerAplic=1.6.2
Versao=1.01
XMotivo=Nenhum documento localizado
arquivo=
dhResp=11/10/2023 11:12:02
indCont=1
maxNSU=000000000000000
tpAmb=2
ultNSU=000000000000000
)
11/10/23 11:12:01:982 - Destravar
 

 

Estamos montando um ambiente Linux para testar com o exemplo em Java.

[Diego Foliene]

Uma observação que talvez valha conferir.

Se verificarmos nas classes em C#, Java e VB6 que são fornecidas pelo ACBr, as mesmas aumentam automaticamente o tamanho do buffer quando o mesmo é pequeno demais em comparação ao tamanho real.

Veja o exemplo em Java onde ele aumenta em 30% o tamanho do buffer.

    protected String processResult(ByteBuffer buffer, IntByReference bufferLen){
        int bLen = bufferLen.getValue();
        if (bLen > STR_BUFFER_LEN) {
            int tamanhoBuffer = (int)(Math.round(bLen * 1.3));
            ByteBuffer nBuffer = ByteBuffer.allocate(tamanhoBuffer);
            IntByReference nBufferLen = new IntByReference(tamanhoBuffer);
            UltimoRetorno(nBuffer, nBufferLen);
            return fromUTF8(nBuffer, nBufferLen);
        }

        return fromUTF8(buffer, bufferLen);
    } 

No exemplo em Node.js que foi fornecido pela comunidade, isso não é feito.

Se possível tente implementar algo nesse sentido para ter uma segurança a mais nessa questão do tamanho do buffer.

[antonio.carlos]

@leoprates por desencargo, além do teste realizado no C# utilizando ACBrLibNFe.dll 
Fiz um teste com a ultima versão ACBrLibNFe.so.. em uma VM utilizando o programa exemplo Java.. veja:


logacbrlib.txt

Referente ao Consumo indevido, foi por conta do teste que Diego fez e logo em seguida eu realizei o teste no Java, necessário aguardar 1 hora, para realizar uma nova consulta.. 

Parece ter alguma relação ao tamanho do buffer.
Veja que o @Diego Foliene comentou como funciona o buffer para o Java, seguimos este padrão para todos os Exemplos.. C#, VB6.. eles também aumentam o tamanho do buffer quando necessário..

[Diego Foliene]

6 horas atrás, Renato Rubinho disse:

Mais uma coisa, a declaração da variável não deveria ser "var", "string", etc?

Em tese uma constante não receberia um retorno.

@leoprates, reforço também o que nosso amigo @Renato Rubinho lhe orientou aqui.

Você está usando:

const aloc_sResposta = Buffer.alloc(BUFF_LENGTH);
const aloc_esTamanho = ref.alloc(ref.types.int, BUFF_LENGTH);

Se conferirmos como é feito no exemplo em node.js disponível no SVN, é usado assim:

let aloc_sResposta = Buffer.alloc(buflength);
let aloc_esTamanho = ref.alloc('int', buflength);

Retirado da Developers Mozila:

Citar

const
A declaração const cria uma variável cujo o valor é fixo, ou seja, uma constante somente leitura. Isso não significa que o valor é imutável, apenas que a variável constante não pode ser alterada ou retribuída.

let

let permite que você declare variáveis limitando seu escopo no bloco, instrução, ou em uma expressão na qual ela é usada. Isso é inverso da keyword var (en-US), que define uma variável globalmente ou no escopo inteiro de uma função, independentemente do escopo de bloco.

 

[leoprates]

Boa tarde a todos! 
 

Estive fora na parte da manhã, então agora vou implementar os ajustes e efetuar os testes que sugeriram. 

Logo menos dou um retorno. Obrigado!

[leoprates]

Pessoal, tentei implementar as sugestões, porém ainda recebo o erro de Segmentation fault.
Vou deixar o código abaixo para que possam avaliar.

 

import ref from "ref-napi";

import acbrDLL from "../acbrDLL";

import EnvProtocol from './protocols/Env.protocol';

import { AcbrProtocol } from './protocols/Acbr.protocol';

import AcbrIniProtocol from './protocols/AcbrIni.protocol';

import { Result } from "./Result";

import { Util } from './Util';

 

interface IResponse {

  success: boolean;

  data?: object | any | undefined;

  message?: string | undefined;

}

 

type ResponseDFes = {

  success: boolean;

  DistribuicaoDFe: any;

  message?: string;

};

 

class Acbr implements AcbrProtocol {

 

  constructor(

    private readonly acbrIni: AcbrIniProtocol,

    private readonly env: EnvProtocol,

    private readonly result: Result,

    private readonly utilResult: Util

  ) { }

 

  private readonly BUFF_LENGTH = 16000;

  private readonly chaveCrypt: string = "";

  private aloc_sResposta = Buffer.alloc(this.BUFF_LENGTH);

  private aloc_esTamanho = ref.alloc(ref.types.int, this.BUFF_LENGTH);

 

  init() {

    let result: number = 0;

    result = acbrDLL.NFE_Inicializar(this.acbrIni.path, this.chaveCrypt);

    this.result.check(result, "NFE_Inicializar");

 

    this.setup();

  }

 

  private setup() {

    this.acbrIni.setValue(

      "DFe",

      "Senha",

      "minha_senha"

    );

 

    this.acbrIni.setValue(

      "Email",

      "Nome",

      this.env.getProperty("MAIL_DESCRIPTION")!!

    );

 

    this.acbrIni.setValue(

      "Email",

      "Servidor",

      this.env.getProperty("MAIL_SERVER")!!

    );

 

    this.acbrIni.setValue(

      "Email",

      "Usuario",

      this.env.getProperty("MAIL_USER")!!

    );

 

    this.acbrIni.setValue(

      "Email",

      "Senha",

      this.env.getProperty("MAIL_PASSWORD")!!

    );

 

    this.acbrIni.setValue(

      "Email",

      "Porta",

      this.env.getProperty("MAIL_PORT")!!

    );

 

    this.acbrIni.setValue("Email", "SSL", this.env.getProperty("MAIL_SSL")!!);

    this.acbrIni.setValue("Email", "TLS", this.env.getProperty("MAIL_TLS")!!);

  }

 

  finish() {

    const result = acbrDLL.NFE_Finalizar();

    this.result.check(result, "NFE_Finalizar");

  }

 

  async getFinalResponse(length: number): Promise<IResponse> {

    return new Promise((resolve, reject) => {

      const aloc_sResposta = Buffer.alloc(length);

      const aloc_esTamanho = ref.alloc(ref.types.int, length);

 

      acbrDLL.NFE_UltimoRetorno.async(

        //@ts-ignore

        aloc_sResposta,

        aloc_esTamanho,

        (err: any, result: any) => {

          try {

            if (err) throw new Error(err);

            this.utilResult.checkResult(result);

            resolve({

              success: true,

              message: Util.sTrim(aloc_sResposta.toString()),

            });

          } catch (error) {

            reject({

              success: false,

              message: error,

            });

          }

        }

      );

    });

  }

 

  async checkPointerResponse(

    result: number,

    alocResposta: Buffer,

    alocLength: ref.Pointer<number>

  ): Promise<any> {

    try {

      this.utilResult.checkResult(result, "NFE_DistribuicaoDFePorUltNSU");

 

      let message = Util.sTrim(alocResposta.toString()) || "";

      const bufferLength = alocLength.deref();

 

      let looping = true;

 

      if (bufferLength <this. BUFF_LENGTH) {

        looping = false;

      } else {

        if (message.length < bufferLength && message.length > this.BUFF_LENGTH) {

          looping = false;

        } else {

          if (message.length >= bufferLength) {

            looping = false;

          }

        }

      }

 

      if (looping === true) {

        // Aumentar o tamanho do buffer em 30%

        const novoTamanho = Math.round(bufferLength * 1.3);

        this.aloc_sResposta = Buffer.alloc(novoTamanho);

        this.aloc_esTamanho = ref.alloc(ref.types.int, novoTamanho);

 

        const resUltimoRetorno = await this.getFinalResponse(novoTamanho);

        if (!resUltimoRetorno.success)

          throw new Error(resUltimoRetorno.message);

 

        message = resUltimoRetorno.message || "";

      }

 

      return {

        success: true,

        data: message,

      };

    } catch (error) {

      return {

        success: false,

        data: error,

      };

    }

  }

 

  getDFesPorUltNSU = async (num_ult_nsu_recebido: string) => {

    console.log("getDFesPorUltNSU");

 

    return new Promise<ResponseDFes>(async (resolve, reject) => {

      const ufAutor = 35;

      const cnpjcpf = "06319316000127";

 

      console.log('NFE_DistribuicaoDFePorUltNSU')

      acbrDLL.NFE_DistribuicaoDFePorUltNSU.async(

        ufAutor,

        cnpjcpf,

        num_ult_nsu_recebido,

        // @ts-ignore

        this.aloc_sResposta,

        this.aloc_esTamanho,

        async (err: any, result: number) => {

          try {

            if (err) {

              console.error(err);

              reject(err);

            }

 

            const response = await this.checkPointerResponse(

              result,

              this.aloc_sResposta,

              this.aloc_esTamanho

            );

 

            console.log({ response });

 

          } catch (error: any) {

            console.error(error);

            reject({

              success: false,

              message: error.message,

            });

          }

        }

      );

    });

  };

 

}

 

export default Acbr;

[Diego Foliene]

2 minutos atrás, leoprates disse:

Pessoal, tentei implementar as sugestões, porém ainda recebo o erro de Segmentation fault.
Vou deixar o código abaixo para que possam avaliar.

 

import ref from "ref-napi";

import acbrDLL from "../acbrDLL";

import EnvProtocol from './protocols/Env.protocol';

import { AcbrProtocol } from './protocols/Acbr.protocol';

import AcbrIniProtocol from './protocols/AcbrIni.protocol';

import { Result } from "./Result";

import { Util } from './Util';

 

interface IResponse {

  success: boolean;

  data?: object | any | undefined;

  message?: string | undefined;

}

 

type ResponseDFes = {

  success: boolean;

  DistribuicaoDFe: any;

  message?: string;

};

 

class Acbr implements AcbrProtocol {

 

  constructor(

    private readonly acbrIni: AcbrIniProtocol,

    private readonly env: EnvProtocol,

    private readonly result: Result,

    private readonly utilResult: Util

  ) { }

 

  private readonly BUFF_LENGTH = 16000;

  private readonly chaveCrypt: string = "";

  private aloc_sResposta = Buffer.alloc(this.BUFF_LENGTH);

  private aloc_esTamanho = ref.alloc(ref.types.int, this.BUFF_LENGTH);

 

  init() {

    let result: number = 0;

    result = acbrDLL.NFE_Inicializar(this.acbrIni.path, this.chaveCrypt);

    this.result.check(result, "NFE_Inicializar");

 

    this.setup();

  }

 

  private setup() {

    this.acbrIni.setValue(

      "DFe",

      "Senha",

      "minha_senha"

    );

 

    this.acbrIni.setValue(

      "Email",

      "Nome",

      this.env.getProperty("MAIL_DESCRIPTION")!!

    );

 

    this.acbrIni.setValue(

      "Email",

      "Servidor",

      this.env.getProperty("MAIL_SERVER")!!

    );

 

    this.acbrIni.setValue(

      "Email",

      "Usuario",

      this.env.getProperty("MAIL_USER")!!

    );

 

    this.acbrIni.setValue(

      "Email",

      "Senha",

      this.env.getProperty("MAIL_PASSWORD")!!

    );

 

    this.acbrIni.setValue(

      "Email",

      "Porta",

      this.env.getProperty("MAIL_PORT")!!

    );

 

    this.acbrIni.setValue("Email", "SSL", this.env.getProperty("MAIL_SSL")!!);

    this.acbrIni.setValue("Email", "TLS", this.env.getProperty("MAIL_TLS")!!);

  }

 

  finish() {

    const result = acbrDLL.NFE_Finalizar();

    this.result.check(result, "NFE_Finalizar");

  }

 

  async getFinalResponse(length: number): Promise<IResponse> {

    return new Promise((resolve, reject) => {

      const aloc_sResposta = Buffer.alloc(length);

      const aloc_esTamanho = ref.alloc(ref.types.int, length);

 

      acbrDLL.NFE_UltimoRetorno.async(

        //@ts-ignore

        aloc_sResposta,

        aloc_esTamanho,

        (err: any, result: any) => {

          try {

            if (err) throw new Error(err);

            this.utilResult.checkResult(result);

            resolve({

              success: true,

              message: Util.sTrim(aloc_sResposta.toString()),

            });

          } catch (error) {

            reject({

              success: false,

              message: error,

            });

          }

        }

      );

    });

  }

 

  async checkPointerResponse(

    result: number,

    alocResposta: Buffer,

    alocLength: ref.Pointer<number>

  ): Promise<any> {

    try {

      this.utilResult.checkResult(result, "NFE_DistribuicaoDFePorUltNSU");

 

      let message = Util.sTrim(alocResposta.toString()) || "";

      const bufferLength = alocLength.deref();

 

      let looping = true;

 

      if (bufferLength <this. BUFF_LENGTH) {

        looping = false;

      } else {

        if (message.length < bufferLength && message.length > this.BUFF_LENGTH) {

          looping = false;

        } else {

          if (message.length >= bufferLength) {

            looping = false;

          }

        }

      }

 

      if (looping === true) {

        // Aumentar o tamanho do buffer em 30%

        const novoTamanho = Math.round(bufferLength * 1.3);

        this.aloc_sResposta = Buffer.alloc(novoTamanho);

        this.aloc_esTamanho = ref.alloc(ref.types.int, novoTamanho);

 

        const resUltimoRetorno = await this.getFinalResponse(novoTamanho);

        if (!resUltimoRetorno.success)

          throw new Error(resUltimoRetorno.message);

 

        message = resUltimoRetorno.message || "";

      }

 

      return {

        success: true,

        data: message,

      };

    } catch (error) {

      return {

        success: false,

        data: error,

      };

    }

  }

 

  getDFesPorUltNSU = async (num_ult_nsu_recebido: string) => {

    console.log("getDFesPorUltNSU");

 

    return new Promise<ResponseDFes>(async (resolve, reject) => {

      const ufAutor = 35;

      const cnpjcpf = "06319316000127";

 

      console.log('NFE_DistribuicaoDFePorUltNSU')

      acbrDLL.NFE_DistribuicaoDFePorUltNSU.async(

        ufAutor,

        cnpjcpf,

        num_ult_nsu_recebido,

        // @ts-ignore

        this.aloc_sResposta,

        this.aloc_esTamanho,

        async (err: any, result: number) => {

          try {

            if (err) {

              console.error(err);

              reject(err);

            }

 

            const response = await this.checkPointerResponse(

              result,

              this.aloc_sResposta,

              this.aloc_esTamanho

            );

 

            console.log({ response });

 

          } catch (error: any) {

            console.error(error);

            reject({

              success: false,

              message: error.message,

            });

          }

        }

      );

    });

  };

 

}

 

export default Acbr;

Por favor, procure sempre disponibilizar em forma de arquivo, disponibilizando como print, dificulta análise dos colegas.

[leoprates]

Ainda com relação ao problema, na maioria das vezes (independente do tamanho so buffer) o erro Segmentation Fault é retornado.
No entanto, algumas vezes o código executa e retorna o erro:
'WebService Distribuição de DFe:- Inativo ou Inoperante tente novamente.\n' +
      'Erro Interno: -2\n' +
      'Erro HTTP: 500\n' +
      'URL: https://hom1.nfe.fazenda.gov.br/NFeDistribuicaoDFe/NFeDistribuicaoDFe.asmx\n' +
      'error:140AB18E:SSL routines:func(171):reason(398)'.

Diego, peço desculpas por ter enviado o código por escrito.

Tentei enviar por arquivo e não consegui. Todas as tentativas a página me deu erro com código -200.

Editado 11 Outubro, 2023 por leoprates

[Renato Rubinho]

 

async getFinalResponse(length: number): Promise<IResponse> {
    return new Promise((resolve, reject) => {
      const aloc_sResposta = Buffer.alloc(length);
      const aloc_esTamanho = ref.alloc(ref.types.int, length);

Na getFinalResponse permanece a aloc_sResposta como const, talvez seja o problema.

Se não resolver mudando a constante acima, como ajustando automaticamente o tamanho do buffer permaneceu o problema, acredito que seja a hora de dar um passo para trás.

Consegue fazer um exemplo bem enxuto, somente com o básico para a comunicação?

Você tem algum outro método funcionando nesta lib? Se tiver, tente fazer um bem enxuto também para compararmos o que funciona com o que está com erro.

[leoprates]

Bom dia Renato! 

Alterei as const para let mas não funcionou.
Os métodos que utilizo antes desse são o NFE_Inicializar e o NFE_ConfigGravarValor que funcionam corretamente.

Simplifiquei ao máximo o método NFe_DistribuicaoDFePorUltNSU mas ao chegar nele é acusado o erro Segmentation fault ou é gerado o log em anexo.

ACBrLibNFE-20231013.log

[Diego Foliene]

Se pesquisarmos esse erro no Google:

 

Citar

140AB18E:SSL routines:func(171):reason(398)

Ele trás 3 resultados, sendo um deles este próprio tópico.

Apelando um pouco mais e pesquisando no ChatGPT, ele nos devolve:

Citar

A mensagem de erro que você forneceu, "140AB18E:SSL routines:func(171):reason(398)," está relacionada ao OpenSSL, uma biblioteca amplamente usada para implementar os protocolos Secure Socket Layer (SSL) e Transport Layer Security (TLS) para comunicação segura pela internet.

Essa mensagem de erro geralmente indica que houve um problema com uma conexão SSL/TLS. O código de erro "140AB18E" pode ser desmembrado da seguinte forma:

O "14" indica que é um erro relacionado ao SSL/TLS.

O "0AB18E" é o código de erro específico que fornece mais detalhes sobre o problema.

O significado exato desse código de erro pode variar dependendo do contexto e da versão específica da biblioteca OpenSSL que você está usando. O erro é um código hexadecimal que corresponde a uma condição de erro específica dentro da biblioteca OpenSSL.

Ambos indicando ser algo relacionado a OpenSSL/Certificado.

Veja se não tem nenhuma outra versão da OpenSSL além da 1.1.1.0 que possa estar conflitando.

Já voltamos um pouco fazendo um programinha mais simples, é possível voltar e testar em um novo ambiente? Primeiro Windows, depois Linux e por fim no Docker?

[leoprates]

Olá, Diego!

No windows tem funcionado sem problema.
Meu microsserviço de emissão de NFE funciona no mesmo ambiente que o de recepção de XML e não da problema com o SSL.
Para sanarmos essa possibilidade removi o openssl instalado, vou criar um novo ambiente no WSL com conda e instalar todas as dependências do zero para testar.
Logo menos retorno. De já, obrigado pelo retorno!

[Daniel Simoes]

Humm. pode ser isso.. o ACBr (ainda) não suporta OpenSSL 3.x.x (estamos trabalhando nisso)

 

[leoprates]

Criei um novo ambiente do zero e o problema continua.

(recepcao-2) root@maure:/home/node/erp-cloud-recepcao-xml-automatica# openssl version
OpenSSL 1.1.1q  5 Jul 2022

Ou da o erro de segmentation


ou o do log

13/10/23 14:24:56:644 - NFe_DistribuicaoDFePorUltNSU(35,06319316000127,000000000000001)

13/10/23 14:24:56:644 - Travar

13/10/23 14:24:56:644 - NFe_DistribuicaoDFePorUltNSU, Executar

13/10/23 14:24:56:700 - Destravar

13/10/23 14:24:56:700 -    SetRetorno(-16, WebService Distribuição de DFe:

- Inativo ou Inoperante tente novamente.

Erro Interno: -2

Erro HTTP: 500

URL: https://hom1.nfe.fazenda.gov.br/NFeDistribuicaoDFe/NFeDistribuicaoDFe.asmx

error:140AB18E:SSL routines:func(171):reason(398)

 

  MotivoRetornadoDoWebService: "")

13/10/23 14:24:56:703 - LIB_UltimoRetorno

13/10/23 14:24:56:703 -    MoverStringParaPChar. StrLen:272, BufLen:39000

13/10/23 14:24:56:703 -    Codigo:-16, Mensagem:WebService Distribui[195][167][195][163]o de DFe:[CR][LF]- Inativo ou Inoperante tente novamente.[LF]Erro Interno: -2[LF]Erro HTTP: 500[LF]URL: https://hom1.nfe.fazenda.gov.br/NFeDistribuicaoDFe/NFeDistribuicaoDFe.asmx[LF]error:140AB18E:SSL routines:func(171):reason(398)[LF][LF]  MotivoRetornadoDoWebService: ""

[leoprates]

Debugando com segfault-handler o retorno é o log abaixo:

 

NFE_DistribuicaoDFePorUltNSU

PID 24905 received SIGSEGV for address: 0x18

/home/node/erp-cloud-recepcao-xml-automatica/.esbuild/.build/node_modules/segfault-handler/build/Release/segfault-handler.node(+0x37a5)[0x7f4bb009f7a5]

/lib/x86_64-linux-gnu/libpthread.so.0(+0x14420)[0x7f4bb23b2420]

/lib/x86_64-linux-gnu/libpthread.so.0(pthread_rwlock_wrlock+0x16)[0x7f4bb23abd46]

node(CRYPTO_THREAD_write_lock+0x9)[0x1966af9]

node(ossl_x509v3_cache_extensions+0x3e)[0x19dbbde]

node(X509_get_extension_flags+0x11)[0x19dca81]

/usr/local/lib/libssl.so(+0x6c4a5)[0x7f4b904c84a5]

/usr/local/lib/libssl.so(SSL_CTX_use_certificate+0x2a)[0x7f4b904a021a]

/home/node/erp-cloud-recepcao-xml-automatica/assets/acbr/dllacbrnfe/bin/Linux/libacbrnfe64.so(+0x50a452)[0x7f4b92425452]

Segmentation fault

[Renato Rubinho]

5 horas atrás, leoprates disse:

Simplifiquei ao máximo o método NFe_DistribuicaoDFePorUltNSU mas ao chegar nele é acusado o erro Segmentation fault ou é gerado o log em anexo

Boa tarde,

Pode anexar o código simplificado para tentarmos simular aqui?

[leoprates]

Claro! 

Estou enviando um link para download, pois ao tentar anexar o arquivo aqui é exibido um erro.

https://mega.nz/file/tjQAWaja#6dOBC3sxUqYrxLQGrXy6beboGcG7ChKENbTq5qMy1JU

 

[Renato Rubinho]

Infelizmente não consegui montar um ambiente com seu exemplo.

Não tenho conhecimento profundo da linguagem e precisaria de um exemplo básico para tentar simular o problema.

Por favor, tente fazer um teste com o demo que temos no projeto( lib_test_teste-acbrlibnfe.js ) adicionando somente o método da Distribuição.

Caso consiga reproduzir o erro com este demo, por favor, anexe o arquivo com seus ajustes para tentarmos simular aqui também.

[Renato Rubinho]

Mais uma coisa, tente configurar o timeout para 30k ou mais, pois a comunicação pode estar sendo derrubada no meio, gerando a exceção.