Bonjour,
Voici un début de code qui doit me permettre d'identifier des morceaux de cahine de caracteres.
[cpp][/cpp]
#include<stdio.h>
#include<unistd.h>
#include<termios.h>
#include<stdlib.h>
#include<string.h>
unsigned int pos_fich;
FILE *Instructions;
char *temp;
 
/*Identification du proxy*/
int Ident_proxy(pos_mem)
{
 
char *proxyI;
int proxy,Ind_flux();
printf("\nDans la fonc %d",pos_mem);
if((proxyI=(char*)malloc (10,sizeof(char*)))==NULL)
{
perror("\nErreur sur allocation de memoire proxyI" );
exit(4);
}
else (memset(*proxyI,0,strlen(proxyI)));
printf("\nrecherche du proxy" );
 
/*Recherche d'un des proxys*/
  do
  {
  sleep(1);
  fseek(Instructions,pos_mem,SEEK_SET);
  proxy=fread(proxyI,sizeof (char),7,Instructions);
  printf("\nrecher de la chaine proxyI %s proxy %d\n\n",proxyI,*(proxyI+6));
    if(*(proxyI+8)==45)
    {
    printf("\nImpossible d'identifier le proxy\n" );
    break;
    }
  pos_mem=pos_mem+1;
  }while((strcmp(proxyI,"Externe" ))!=0 && (strcmp(proxyI,"Interne" ))!=0 && *(proxyI+13)!=10);
printf("\nValeur avant %d",pos_mem+strlen(proxyI));
/*On appel la fonction pour identifier le type de flux*/
  if(!strcmp(proxyI,"Externe" ))
  {
  printf("\nProxy Identifié : Externe" );
  pos_mem=Indent_flux(pos_mem+strlen(proxyI),proxyI);
  }
   
  if(!strcmp(proxyI,"Interne" ))
  {
  printf("\nProxy Identifié : Interne" );
  pos_mem=Indent_flux(pos_mem+strlen(proxyI),proxyI);
  }
   
if(*(proxyI+7)==10)
printf ("\nProxy non identifié %d %d\n",strlen(proxyI),pos_mem+strlen(proxyI));
 
sleep(2);
printf("\nValeur retournée au main %d",pos_mem);
free(proxyI);
return(pos_mem);
 
}
 
 
 
 
/*Identification du flux a traiter*/
int Indent_flux(pos_mem2,proxyI)
{
char *FluxId,*temp_flux,*tampon;
int flux;
fseek(Instructions,pos_mem2,SEEK_SET);  
printf("\nRecherche du type de flux impacté %d",pos_mem2);
printf("\nValeur reçue %d type de proxy %s",pos_mem2,proxyI);
  if((FluxId=(char*)malloc (3,sizeof(char*)))==NULL)
  {
  fprintf(stderr,"\nErreur sur allocation de memoire FluxId" );
  exit(4);
  }
else (memset(*FluxId,0,strlen(FluxId)));
 
  if((temp_flux=(char*)malloc (10,sizeof(char*)))==NULL)  
  {
  fprintf(stderr,"\nErreur sur allocation de memoire temp_flux" );
  exit(4);
  }
else (memset(*temp_flux,0,strlen(temp_flux)));
 
if((tampon=(char*)malloc (2,sizeof(char*)))==NULL)  
  {
  fprintf(stderr,"\nErreur sur allocation de memoire tampon" );
  exit(4);
  }
else (memset(*tampon,0,strlen(temp_flux)));
 /*if((flux=fread(FluxId,sizeof (char),1,Instructions))<1)
  printf("\nErreur de lecture sur premier caractère d'identification du flux a traiter" );
  pos_mem2=pos_mem2+1;*/
  do
  {
  printf ("\ndans la boucle pos_mem2 = %d",pos_mem2);
  fseek(Instructions,pos_mem2,SEEK_SET);  
  printf("\ntampon= %c flux= %d temp_flux :%d taille %d",*tampon,flux,*temp_flux,strlen(FluxId));
  if((flux=fread(tampon,sizeof (char),1,Instructions))<1)
  printf("\nErreur de lecture sur premier caractère d'identification du flux a traiter" );
   strcat(FluxId,tampon);
   temp_flux=FluxId;
   if(FluxId=realloc(temp_flux,strlen(temp_flux)+2)==NULL)
   printf("\nErreur sur reallocation memoire FluxId" );
   FluxId=temp_flux;
   sleep(1);
   pos_mem2=pos_mem2+1;
  }while(*(tampon+0)!=10);
  printf("\nsortie de boucle type de flux identifié : %s %d",FluxId,pos_mem2);
  free(FluxId);
  free(temp_flux);
  free(tampon);
return(pos_mem2);
}
   
   
   
                                       
/*Debut de routine principale*/
main(argc,fichier_instructions)
int argc;
char **fichier_instructions;
{
char *proxy,*modif,*type_modif,*temp2,*fin,fin_fich;
FILE *fichier_modif;
int resultat,taille,compt,Ident_proxy();
unsigned long int retour;
compt=0;
if(argc<2)
{
fprintf(stderr,"\nErreur sur le nombre de paramétres a founir\nDonnez un nom de fichier\n" );
exit(1);
}
printf ("\nOuverture du fichier ACL passer en argument %s\n",fichier_instructions[1]);
if((Instructions=fopen(fichier_instructions[1],"r" ))==NULL)
{
fprintf(stderr,"\nOuverture du fichier d'ACL impossible\nFichier incorrect ou inexistant\n" );
exit(2);
}
else printf("\nOuverture OK\n" );
/*Allocation de zone memoire pour la detection de "Fichier à modifier : "*/
if((temp=(char*)malloc (22,sizeof(char*)))==NULL)
{
fprintf(stderr,"\nErreur sur allocation de memoire" );
exit(3);
}
else memset(*temp,0,strlen(temp));
/*Allocation d'une zone memoire pour la lecture de caractere suivant*/
if((temp2=(char*)malloc (2,sizeof(char*)))==NULL)
{
fprintf(stderr,"\nErreur sur allocation de memoire" );
exit(3);
}
else (memset(*temp2,0,strlen(temp2)));
pos_fich=0;
printf("\nRecherche du proxy et de l'ACL à modifier valeur de resultat %d %d\n\n",resultat=1,Instructions);
printf("\nValeur de temp %s et *temp+21 %c resultat %d\n\n",temp,*(temp+20),sizeof(char));
 
/*Recherche du type de proxy*/
do
  {
  fseek(Instructions,pos_fich,SEEK_SET);
  resultat=fread(temp,sizeof (char),21,Instructions);
  if(!strcmp(temp,"Fichier à modifier : " ))
    {
    printf("\n\nTraitement du bloc %d",compt=compt+1);
    printf("\nIdentification du proxy OK valeur de pos_fich %d",pos_fich+strlen(temp));
    pos_fich=Ident_proxy(pos_fich+strlen(temp));
    }
    else
    pos_fich=pos_fich+1;
  /*write(1,temp,21);*/
  /*sleep(1);*/
}while(!feof(Instructions));
 
/*Sortie de recherche de proxy*/
free(temp);
free(temp2);
fclose(Instructions);
}
[cpp][/cpp]
 
Quand je lance ce programme avec en argument,
un nom de fichierun premier passage s'effectue sans probleme sur toutes les fonctions.
Mais le deuxieme s'arrete dans la fontio Ident_proxy a la premiere allocation de memoire
et l'os me fait un fichier core..
Merci pour l'aide.

Salut a tous,
J'ai trouvé c'est le malloc dans les fonctions qui coince.
J'airemplacé par calloc et c'est ok.
Mais pourquoi malloc coince quand il est appelé plusieurs fois?