private byte[] criaPacoteDados(byte checkSumCabecalho, Digital digital)
{
byte[] requisicao = new byte[] { 0x01, 0x20, 0x03 }; // bytes fixos
String dedoAux = digital.template1.Substring(6); // desconsidera os 3 primeiros bytes (fixados acima)
dedoAux += digital.template2;
requisicao = ProtocolUtils.merge(requisicao, Conversor.hexStringToByteArray(dedoAux));
byte checksum = ProtocolUtils.getChecksum(ProtocolUtils.merge(requisicao, new byte[] { checkSumCabecalho, Convert.ToByte(CommandCodes.END) }));
requisicao = ProtocolUtils.merge(requisicao, new byte[] { checksum });
return(requisicao);
}
public static byte[] DecToBCDArray(long num)
{
int digits = 0;
long temp = num;
while (temp != 0)
{
digits++;
temp /= 10;
}
int byteLen = digits % 2 == 0 ? digits / 2 : (digits + 1) / 2;
Boolean isOdd = digits % 2 != 0;
byte[] bcd = new byte[byteLen];
for (int i = 0; i < digits; i++)
{
byte tmp = (byte)(num % 10);
if (i == digits - 1 && isOdd)
{
bcd[i / 2] = tmp;
}
else if (i % 2 == 0)
{
bcd[i / 2] = tmp;
}
else
{
byte foo = (byte)(tmp << 4);
bcd[i / 2] |= foo;
}
num /= 10;
}
for (int i = 0; i < byteLen / 2; i++)
{
byte tmp = bcd[i];
bcd[i] = bcd[byteLen - i - 1];
bcd[byteLen - i - 1] = tmp;
}
if (bcd.Length == 1)
{
bcd = ProtocolUtils.merge(new byte[] { 0, 0 }, bcd);
}
else if (bcd.Length == 2)
{
bcd = ProtocolUtils.merge(new byte[] { 0 }, bcd);
}
return(bcd);
}
private byte[] criaPacoteDados(byte checkSumCabecalho, byte[] cpf, Company company)
{
byte tipoId;
byte[] identificador;
tipoId = 0x01;
identificador = Conversor.cnpjToByte(Conversor.SomenteNumeros(Conversor.SomenteNumeros(company.cnpj))); // Campo Identificador 6 bytes
byte[] requisicao = { tipoId }; // Campo Tipo de Identificador 1 byte
byte[] cei = Conversor.ceiToByte(Conversor.SomenteNumeros(company.cei)); // Campo CEI 5 bytes
byte[] razaoSocial = Conversor.stringToByteArray(company.companyName, 150); // Campo Razão Social 150 bytes
byte[] localPrestServ = Conversor.stringToByteArray(company.address + " " + company.city, 100); // Campo Local 100 bytes
requisicao = ProtocolUtils.merge(requisicao, identificador, cei, razaoSocial, localPrestServ, cpf);
byte checksum = ProtocolUtils.getChecksum(ProtocolUtils.merge(requisicao, new byte[] { checkSumCabecalho, Convert.ToByte(CommandCodes.END) }));
requisicao = ProtocolUtils.merge(requisicao, new byte[] { checksum });
return(requisicao);
}
public static byte[] criarPacoteCabecalho(int start, int codigoComando, byte[] parametro, byte[] tamanho, byte[] cpfPis, byte flag, int end)
{
try
{
byte[] requisicao = new byte[] {
((byte)(start)),
0,
0,
0,
0,
((byte)(codigoComando))
};
// Campo Comando 1 byte
requisicao = ProtocolUtils.merge(requisicao, parametro);
// Campo Par�metro 4 bytes
requisicao = ProtocolUtils.merge(requisicao, tamanho);
// Campo Tamanho 4 bytes
requisicao = ProtocolUtils.merge(requisicao, cpfPis);
// Campo CPF/PIS 6 bytes
requisicao = ProtocolUtils.merge(requisicao, new byte[] {
flag
});
// Campo Flag/Erro 1 byte
requisicao = ProtocolUtils.calcularChecksum(requisicao);
// Campo BCC 1 byte
requisicao = ProtocolUtils.merge(requisicao, new byte[] {
((byte)(end))
});
// Campo Flag/Erro 1 byte
return(requisicao);
}
catch (Exception e)
{
return(null);
}
}
private void enviaBlocoVazio(byte[] bytes, Boolean incluirBytesNoInicio)
{
byte[] blocoVazio = new byte[AES.QTD_BYTES_BLOCO - bytes.Length];
for (int i = 0; i < blocoVazio.Length; i++)
{
blocoVazio[i] = (byte)0xFF;
}
if (incluirBytesNoInicio)
{
blocoVazio = ProtocolUtils.merge(bytes, blocoVazio);
byte[] blocoVazioAux = new byte[AES.QTD_BYTES_BLOCO];
for (int i = 0; i < blocoVazioAux.Length; i++)
{
blocoVazioAux[i] = (byte)0xFF;
}
blocoVazio = ProtocolUtils.merge(blocoVazio, blocoVazioAux);
}
else
{
blocoVazio = ProtocolUtils.merge(blocoVazio, bytes);
}
sendBuffer(blocoVazio, true, tcp);
}
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);
}
