Falha de segmentação

[x_file 0]

Bom dia a todos estou com uma dúvida. Tenho um array de bytes que utilizo numa rotina para calcular o CRC porém consigo compilar no gcc mas quando vou executar... o gcc me retorna falha de segmentação. Alguém poderia me dizer o que isso quer dizer sendo que o código está correto ?

#include <stdio.h>
#include <string.h>
#include <stdlib.h>


int main(int argc, char *argv[]){

unsigned char resultado[100];
unsigned char  teste[17];
teste[0] = 0x81;
teste[1] = 0x01;
teste[2] = 0x01;
teste[3] = 0x00;
teste[4] = 0x0C;
teste[5] = 0x01;
teste[6] = 0x00;
teste[7] = 0x01;
teste[8] = 0x01;
teste[9] = 0x00;
teste[10] = 0x44;
teste[11] = 0x00;
teste[12] = 0x04;
teste[13] = 0x00;
teste[14] = 0x00;
teste[15] = 0x03;
teste[16] = 0xFF;

montaCRC(teste,0,17,resultado);

}


int montaCRC(unsigned char * byteDados, unsigned char * teste, int byteinicial, int qBytes, unsigned char * resultado){
 
   
     int m_acumulado = 0;
     int dado;
     int i2;
     int bl;
     char chave[2];
            chave[0] = 0x10;
            chave[1] = 0x21;
     
     int iByteInicial = byteinicial;
     int iqBytes = qBytes;
     int i;
     int Contador;
             
     for( i = iByteInicial; i < (iByteInicial + iqBytes); i++ )
     {
         dado = (int)byteDados[i];
         dado <<= 8;
         for (Contador =0; Contador<8; Contador++)
         {
                if(((dado ^ m_acumulado) & 0x8000) !=0)                   // ^ and & or
                {                    
                    m_acumulado = (m_acumulado << 1) ^ (int)chave;       // << deslocamento de bits
                }
                else
                {
                    m_acumulado <<=1;
                
                }
              
                dado <<=1;
                i2 = m_acumulado;
                i2 >>=8;  
            }
        }
         
        i2 = m_acumulado;
        i2 >>=8;
        
        resultado[1] =  (unsigned char) ((char)m_acumulado); 
        m_acumulado >>=8;
        resultado[0] = (unsigned char) ((char)m_acumulado);
        
         printf("**********Resultado do CRC 1: %X\n",resultado[0]);
         printf("**********Resultado do CRC 2: %X\n",resultado[1]);
         
       //return (1);
}

[VictorCacciari 42]

CRC não é aquele hash pra verificar se dois arquivos são iguais???

Não sei muito sobre o assunto....

 

Mas sobre a falha de segmentação eu acho que posso te ajudar! :P

Significa que você está a acessar alguma coisa na memória, que na realidade não existe.

 

Primeira coisa... o que é aquele segundo argumento da função "montaCRC"???

unsigned char * teste

e você passa o inteiro '0' pra ele...

 

Outra, a fnção declarada como "int" DEVE retornar um inteiro... isso vale para main também!

Eu retirei o segundo argumento da função, deixando-a assim:

int montaCRC(unsigned char * byteDados, int byteinicial, int qBytes, unsigned char * resultado)

E o output foi:

**********Resultado do CRC 1: DC

**********Resultado do CRC 2: D6

 

Se possível, diga-nos em que linha acontece a falha de segmentação.

http://forum.imasters.com.br/public/style_emoticons/default/thumbsup.gif

[x_file 0]

na verdade esse CRC seria como o os dois últimos numeros de um CPF...por ex. enfim tirei do argumento *teste e consegui rodar, meu output foi diferente do seu

**********Resultado do CRC 1: B3

**********Resultado do CRC 2: E4

 

ainda não está calculando correto preciso rever a lógica, mas já consigo executar obrigado pela ajuda victor

[VictorCacciari 42]

Sim, CRC é uma função Hash... inputs iguais levam a outputs iguais.

 

Ainda bem que pude ajudar.

[omar.pessoa 1]

Ciclical Redundance Check!!!

 

Só para ajudar! Não necessariamente é um hash!

 

http://pt.wikipedia.org/wiki/CRC

[VictorCacciari 42]

[...]um tipo de função hash que gera um valor expresso em poucos bits em função de um bloco maior de dados, como um pacote de dados, ou um ficheiro, por forma a detectar erros de transmissão ou armazenamento[...]

 

Até que eu não estava tão mal assim... :P