public byte[] readAnswer(Tcp tcp, int qtdBytesBuffer)
{
byte[] retorno = new byte[qtdBytesBuffer];
int qdeRecebida = tcp.recebeBytes(retorno, 0, qtdBytesBuffer, Protocol.TIMEOUT);
if ((qdeRecebida == -1))
{
return(null);
}
else if ((qdeRecebida != qtdBytesBuffer))
{
return(new byte[0]);
}
retorno = AES.Decrypt(retorno);
return(retorno);
}
public static void sendBuffer(byte[] buffer, bool sendAll, Tcp tcp)
{
byte[] bufferCriptografado = AES.Encrypt(buffer);
tcp.enviaBytes(bufferCriptografado);
}
public ErrorCommand execute(String ip, String porta, String cpf, Company company)
{
ErrorCommand errorCommand = new ErrorCommand();
Tcp tcp = null;
try
{
tcp = new Tcp(ip, Convert.ToInt16(porta));
}
catch (IOException e) {
errorCommand.setErro(ErrorCommand.SUCESSO);
return(errorCommand);
}
try
{
try
{
byte[] bytesCpf = Conversor.cpfToByte(cpf);
byte[] cabecalhoDadosGravaEmpregador = Command.criarPacoteCabecalho(CommandCodes.START_PC, CommandCodes.ENVIAR_EMPREGADOR, new byte[] { 0x00, 0x00, 0x00, 0x01 }, new byte[4], bytesCpf, (byte)ErrorCommand.ADICIONAR_SUBSTITUIR, CommandCodes.END);
// Envia o cabeçalho
sendBuffer(cabecalhoDadosGravaEmpregador, true, tcp);
// Lê 1ª resposta do REP
byte[] retornoReal = readAnswer(tcp, Protocol.QTD_BYTES_CABECALHO_CRIPTOGRAFADO);
int qtdBytesRecebidos = -1;
if (retornoReal != null)
{
qtdBytesRecebidos = retornoReal.Length;
}
// Trata a 1ª resposta do REP
errorCommand = tratarResposta(CommandCodes.ENVIAR_EMPREGADOR, retornoReal, qtdBytesRecebidos, Protocol.QTD_BYTES_CABECALHO_CRIPTOGRAFADO);
if (errorCommand.getErro() == ErrorCommand.SUCESSO)
{
cabecalhoDadosGravaEmpregador = criarPacoteCabecalho(CommandCodes.START_PC, CommandCodes.ENVIAR_EMPREGADOR,
new byte[] { 0x00, 0x01, 0x00, 0x01 }, new byte[] { 0x00, 0x00, 0x01, 0x0C },
bytesCpf, (byte)ErrorCommand.DADOS_OK, CommandCodes.END);
byte checkSumCabecalho = cabecalhoDadosGravaEmpregador[cabecalhoDadosGravaEmpregador.Length - 2];
byte[] dadosGravaEmpregador = criaPacoteDados(checkSumCabecalho, bytesCpf, company);
// Envia os dados do empregador
sendBuffer(ProtocolUtils.merge(cabecalhoDadosGravaEmpregador, dadosGravaEmpregador), true, tcp);
retornoReal = new byte[Protocol.QTD_BYTES_CABECALHO_CRIPTOGRAFADO];
// Lê 2ª resposta do REP
retornoReal = readAnswer(tcp, Protocol.QTD_BYTES_CABECALHO_CRIPTOGRAFADO);
qtdBytesRecebidos = -1;
if (retornoReal != null)
{
qtdBytesRecebidos = retornoReal.Length;
}
// Trata a 2ª resposta do REP
errorCommand = tratarResposta(CommandCodes.ENVIAR_EMPREGADOR, retornoReal, qtdBytesRecebidos, Protocol.QTD_BYTES_CABECALHO_CRIPTOGRAFADO);
}
}
catch (Exception e)
{
errorCommand.setErro(ErrorCommand.OCORREU_EXCECAO);
}
tcp.finalizaConexao();
}
catch (Exception e)
{
errorCommand.setErro(ErrorCommand.ERRO_FINALIZAR_CONEXAO);
}
return(errorCommand);
}
public ErrorCommand execute(String ip, String porta, List <Digital> digitals, String pis)
{
errorCommand = new ErrorCommand();
tcp = null;
try
{
tcp = new Tcp(ip, Convert.ToInt16(porta));
}
catch (IOException e1) {
errorCommand.setErro(ErrorCommand.COMUNICACAO_NAO_ESTABELECIDA);
return(errorCommand);
}
int totalDigitais = 0;
try
{
try
{
totalDigitais = digitals.Count;
int digitalAtual = 1;
byte flag;
if (totalDigitais == 1)
{
flag = ErrorCommand.UNICA_TEMPLATE_USUARIO;
}
else
{
flag = ErrorCommand.TODAS_TEMPLATE_USUARIO;
}
byte[] cabecalhoDadosGravaDigital = criarPacoteCabecalho(CommandCodes.START_PC, CommandCodes.ENVIAR_DIGITAL,
new byte[] { 0x00, 0x00, 0x00, (byte)totalDigitais }, new byte[4],
Conversor.pisToByte(pis),
flag, CommandCodes.END);
byte[] primeiroBlocoCabecalho = ProtocolUtils.copyOfRange(cabecalhoDadosGravaDigital, 0, 16); // primeiros 16 bytes do cabeçalho
// Envia o cabeçalho
sendBuffer(primeiroBlocoCabecalho, true, tcp);
/**
* Envio dos bytes do cabeçalho ainda não enviados + bloco vazio (0xFF).
* Isto é necessário para o REP reconhecer tudo corretamente (visto empiricamente).
*/
Boolean incluirBytesNoInicio = true;
enviaBlocoVazio(ProtocolUtils.copyOfRange(cabecalhoDadosGravaDigital, 16, cabecalhoDadosGravaDigital.Length), incluirBytesNoInicio);
// Lê 1ª resposta do REP
lerEtratarResposta(Protocol.QTD_BYTES_CABECALHO_CRIPTOGRAFADO);
if (errorCommand.getErro() == ErrorCommand.SUCESSO)
{
errorCommand.setErro(ErrorCommand.DADOS_OK);
incluirBytesNoInicio = false;
for (; (digitalAtual <= totalDigitais) && (errorCommand.getErro() == ErrorCommand.DADOS_OK); digitalAtual++)
{
cabecalhoDadosGravaDigital = criarPacoteCabecalho(CommandCodes.START_PC, CommandCodes.ENVIAR_DIGITAL,
new byte[] { 0x00, (byte)totalDigitais, 0x00, (byte)digitalAtual },
new byte[] { 0x00, 0x00, 0x03, 0x23 }, // 803 bytes
new byte[6], (byte)ErrorCommand.DADOS_OK, CommandCodes.END);
byte checkSumCabecalho = cabecalhoDadosGravaDigital[cabecalhoDadosGravaDigital.Length - 2];
Digital digitalComunicador = digitals[digitalAtual - 1];
byte[] dadosGravaDigital = criaPacoteDados(checkSumCabecalho, digitalComunicador);
/**
* Envio de bloco vazio:
* Necessário para o REP reconhecer tudo corretamente (visto empiricamente).
*/
if (digitalAtual == 1)
{
enviaBlocoVazio(ProtocolUtils.copyOfRange(cabecalhoDadosGravaDigital, 0, 2), incluirBytesNoInicio);
// Envia a digital
sendBuffer(ProtocolUtils.merge(ProtocolUtils.copyOfRange(cabecalhoDadosGravaDigital, 2, cabecalhoDadosGravaDigital.Length), dadosGravaDigital), true, tcp);
}
else
{
primeiroBlocoCabecalho = ProtocolUtils.copyOfRange(cabecalhoDadosGravaDigital, 0, 16); // primeiros 16 bytes
sendBuffer(primeiroBlocoCabecalho, true, tcp);
// Envia a digital
sendBuffer(ProtocolUtils.merge(ProtocolUtils.copyOfRange(cabecalhoDadosGravaDigital, 16, cabecalhoDadosGravaDigital.Length), dadosGravaDigital), true, tcp);
}
// Lê e trata 2ª resposta do REP
lerEtratarResposta(Protocol.QTD_BYTES_CABECALHO_CRIPTOGRAFADO);
incluirBytesNoInicio = true;
}
}
}
catch (Exception e)
{
errorCommand.setErro(ErrorCommand.OCORREU_EXCECAO);
}
tcp.finalizaConexao();
}
catch (Exception e)
{
errorCommand.setErro(ErrorCommand.ERRO_FINALIZAR_CONEXAO);
}
return(errorCommand);
}
