Analyse des visites d'un site Web (log) en C

Voila le sujet
********************************

Les serveurs web enregistrent la trace des visites dans des fichiers de log. Chaque requète (demande d'une page par un navigateur internet) génère une ligne dans un fichier de log (normalement nommé access_log. Ce fichier est utilisé par le webmaster pour déterminer quels sont les pages les plus visitées, combien de visiteurs passent sur le site, etc.
Le but de ce projet est d'écrire un programme permettant d'aider un webmaster à analyser le comportement de ses visiteurs.

Voici un extrait du fichier de log du serveur web de l'IUT:


193.249.12.70 - - [31/Dec/2000:22:26:14 +0500] "GET /precamp.html HTTP/1.1" 200 4775
194.231.30.90 - - [31/Dec/2000:22:26:41 +0500] "GET / HTTP/1.0" 200 6266
193.249.12.70 - - [31/Dec/2000:22:27:01 +0500] "GET /gtr.html HTTP/1.1" 200 9010
64.39.31.110 - - [01/Jan/2001:11:35:08 +0500] "GET / HTTP/1.0" 200 6266
212.217.125.156 - - [01/Jan/2001:21:05:50 +0500] "GET /images/logoiut.gif HTTP/1.0" 200 646
212.217.125.156 - - [01/Jan/2001:21:05:50 +0500] "GET /images/logou2.jpeg HTTP/1.0" 200 3978
212.217.125.156 - - [01/Jan/2001:21:06:16 +0500] "GET /gea.html HTTP/1.0" 200 10052
64.39.31.110 - - [01/Jan/2001:23:26:34 +0500] "GET / HTTP/1.0" 200 6266
216.36.21.13 - - [02/Jan/2001:05:39:42 +0500] "GET / HTTP/1.1" 200 6266
216.36.21.13 - - [02/Jan/2001:05:39:43 +0500] "GET /images/fd.jpeg HTTP/1.1" 200 2089

Les lignes du fichier ont toujours la même structure~: adresse IP du visiteur, date de la requète, requète HTTP. On ignorera la suite de la ligne.
La requète HTTP est normalement GET (on ignorera les autres requètes) et permet de retrouver le nom de la page ou de l'image demandée. Ainsi "GET / HTTP/1.0" est une requète qui demande la page d'accueil (/) du site.

Notons qu'une page qui comporte des images demande plusieurs requètes pour être chargée.

Objectif du programme
Votre programme permettra, à partir d'un fichier de log que l'on vous fournira (fichiers access_log), d'afficher les informations suivantes:
nombre de visites: une visite est caractérisée par le passage d'un visiteur, qui demande quelques pages puis quitte le site. Attention, plusieurs visiteurs peuvent etre actifs simultanément. On introduira un seuil temporel réglable (par exemple, on considera une visite comme terminée s'il n'y a pas de requète depuis 3 minutes). Un visiteur est caractérisé par son adresse IP.
hit parade des pages: afficher la liste des pages vues, triée par nombre de visiteurs.
hit parade des visiteurs: afficher la liste des visiteurs, trié par nombre de visite effectuées.
hit parade des dates: afficher les dates où il y a eu le plus de visites.
Question subsidiaire (non facultative)
Chercher sur Internet des programmes gratuits faisant ce genre de traitements. Quels sont les fonctionnalités qui manquent au votre ?

******************************************************
Puis voila le truc qu'on a recupere par un pote ::)

#include<c:\mesdoc~1\c\projet\WebLog.h>
#include<string.h>
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<math.h>
#define maxi 100


/*************************** Structure Ligne ******************************

cette structure permet de classer : -l'adresse IP du visiteur,
-la date et l'heure de sa visite
-le site et la page visit‚ */

typedef struct { char IP[20]; char date[22];
int heure; int minutes;
char site[50]; char page[50];
} Ligne;


/************************ Fonction scanlog *******************************

cette fonction lit les lignes du fichier log caractere par caractere
et les recopie dans un tableau de structure de type Ligne. */

void scanlog(FILE*LOG,int*nb_ligne,Ligne *Visite);

/*********************** Fonction nb_de_visites **************************

cette fonction calcul le nombre de visites effectu‚es et affiche
le r‚sultat a l'ecran. */

void nb_de_visites(Ligne *Visite,int *nb_ligne,int *tempo);

/*********************** Fonctions " hit parades " ***********************

ces fonction effectuent des classements par nombre de visites */

void hit_des_pages(Ligne*Visite,int *nb_ligne);
void hit_des_visiteurs(Ligne*Visite,int *nb_ligne,int *tempo);
void hit_des_dates(Ligne*Visite,int *nb_ligne,int *tempo);



// *********************** Fonction principale *****************************

void main()
{
FILE *fic_log;
Ligne Visite[maxi]; // tableau de maxi Ligne
int nb_ligne, tempo;

clrscr();


// ********************* ouverture du fichier log ***************************

// fic_log=fopen("u:\\combes\\projet\\log.txt","r");
fic_log=fopen("c:\\mesdoc~1\\c\\projet\\log.txt","r");

// ************** teste si le fichier log existe ou non *********************
// si non : message d'erreur
// si oui : le programme continu

if(fic_log==NULL)
printf("\n erreur : le fichier LOG.TXT n'existe pas");

else
{

// ******** choix des parametres necessaire a l'execution du programme ******
// temporisation determinant la fin d'une visite

gotoxy(23,12);
printf("Analyse des visites d'un site Web");
fflush(stdin);
getchar();
clrscr();
gotoxy(21,12);
printf("Quel seuil temporel d‚sirez-vous ? ");
scanf("%d",&tempo);


// ****************** Appel de la fonction " scanlog " **********************

scanlog(fic_log,&nb_ligne,&Visite);

// ***************** Appel des fonctions " hit parade " *********************

nb_de_visites(&Visite,&nb_ligne,&tempo);
hit_des_pages(&Visite,&nb_ligne);
hit_des_visiteurs(&Visite,&nb_ligne,&tempo);
hit_des_dates(&Visite,&nb_ligne,&tempo);
}


fclose(fic_log); // fermeture du fichier log

gotoxy(5,25);
printf("Appuyez sur une touche pour terminer...");
while(!kbhit());

}


// ************************* Fonction scanlog ******************************

void scanlog(FILE*LOG,int*nb_ligne,Ligne*Visite)
{
// declaration des variables

int i=0,j,d,s,p;
char c,tmp='a';

/* scanne caractere par caractere le fichier log
tant que celui ci n'est pas termin‚ */

while(!feof(LOG))
{
fscanf(LOG,"%c",&tmp);
if(tmp=='\n') // si le caractere est '\n'
return; // on la fonction est termin‚e

j=0;d=0;s=0,p=0; // initialisation des variable

// ********************** classement des adresse IP ************************
do
{
Visite[i].IP[j]=tmp;
fscanf(LOG,"%c",&tmp);
j++;
}
while(tmp!=' ');
Visite[i].IP[j]='\0';//pour terminer la chaine de caracteres

do
fscanf(LOG,"%c",&tmp);
while(tmp!='[');

// ********************** classement des dates *****************************
do
{
fscanf(LOG,"%c",&Visite[i].date[d]);
tmp=Visite[i].date[d];
d++;
}
while(tmp!=':');
d--;
Visite[i].date[d]='\0';

// **************** classement de l'heure et des minutes *******************

fscanf(LOG,"%d",&Visite[i].heure);
fscanf(LOG,"%c",&tmp);
fscanf(LOG,"%d",&Visite[i].minutes);

do
fscanf(LOG,"%c",&tmp);
while(tmp!='/');

// ********************** classement des sites *****************************
do
{
fscanf(LOG,"%c",&Visite[i].site[s]);
tmp=Visite[i].site[s];
s++;
}
while(tmp!='/');
s--;
Visite[i].site[s]='\0';

// ********************** classement des pages ****************************
Visite[i].page[0]='/';
do
{
p++;
fscanf(LOG,"%c",&Visite[i].page[p]);
tmp=Visite[i].page[p];
}
while(tmp!='\"');

Visite[i].page[p]='\0';

// on scanne jusqu'en fin de ligne de facon a positionner le curseur
// au debut de la ligne suivante
do
fscanf(LOG,"%c",&tmp);
while(tmp!='\n');

i++;
*nb_ligne=i;
}

}
// ************************* Fonction nb_de_visites *************************

void nb_de_visites(Ligne *Visite,int *nb_ligne,int *tempo)
{

/* cette fonction consiste a determiner le nombre de visite effectu‚es
en comparant les lignes du fichier log :
- adresse IP
- site
- date/heure ... */

// Declaration des variables

int b, i, j, k, l, comp, nb_visite;
char tmp;
tableau memoire;

// initialisation des variables

memoire.nb=0; l=0;
// au depart on considere qu'il y a autant de visites que de lignes
nb_visite=*nb_ligne;

for(j=0;j<*nb_ligne-1;j++) // pour toutes les lignes
{
while(j==memoire.tab[l]) // ces 2 lignes evitent de repeter
{ j++; l++; } // plusieurs fois la meme comparaison

for(i=j+1;i<*nb_ligne;i++)
{ // comparaison des IP de i et de j
comp=strcmp(Visite[j].IP,Visite[i].IP);
if(comp==0)
{ // comparaison des sites
comp=strcmp(Visite[j].site,Visite[i].site);
if(comp==0)
{ // comparaison des dates
comp=strcmp(Visite[j].date,Visite[i].date);
if(comp==0)
{ // comparaison des heures
if(Visite[j].heure==Visite[i].heure)
{
comp=1;
// comparaison des minutes avec une marge de + ou - 'tempo'
for(k=-*tempo;(k<=*tempo)&&(comp!=0);k++)
{
if(Visite[j].minutes==Visite[i].minutes+k)
comp=0;
}
// si toutes les comparaisons sont 'vraies' : on retire 1 a nb_visites
if(comp==0)
{
nb_visite--;
/* on insere i dans un tableau */ insere(i,&memoire,&b);
/* pour eviter les repetitions */ if (b==0)
printf("\n\nERREUR!!!! tableau plein");
}}}}}}}
// ********************** affichage du nb de visite *************************

clrscr();
gotoxy(25,10);
printf("Nombre de visites effectu‚es :");
gotoxy(36,14);
printf(" %d ",nb_visite);
fflush(stdin);
getchar();

}

// ************************* Fonction hit_des_pages *************************


void hit_des_pages(Ligne*Visite,int *nb_ligne)
{
// declaration des variables

int b, i, j, l, p, comp;
tableau memoire;
Hit page[maxi],page_tri[maxi];

// initialisation des variables
memoire.nb=0; l=0; p=0;


for(j=0;j<*nb_ligne-1;j++)
{
while(j==memoire.tab[l]) // ces 2 lignes evitent de repeter
{ j++; l++; } // plusieurs fois la meme comparaison

page[p].nb=1; // nb de visites de la page p = 1
// copie des pages et des sites dans la structure : page p
strcpy(page[p].objet1,Visite[j].site);
strcpy(page[p].objet2,Visite[j].page);
p++; // incrementation de p pour passer a la page suivante

for(i=j+1;i<*nb_ligne;i++)
{ // comparaison des sites
comp=strcmp(Visite[j].site,Visite[i].site);
if(comp==0)
{ // comparaison des pages
comp=strcmp(Visite[j].page,Visite[i].page);
// si c'est la meme page : incrementation de page[p-1].nb
if(comp==0)
{
page[p-1].nb++;
/* on insere i dans un tableau */ insere(i,&memoire,&b);
/* pour eviter les repetitions */ if (b==0)
printf("\n\nERREUR!!!! tableau plein");

}}}}

tri(&page,&page_tri,&p);

// ********************** affichage du Hit des Pages ************************

clrscr();
gotoxy(23,12);
printf("Hit parade des Pages consult‚es:\n");
fflush(stdin);
getchar();
// p--;
affiche(&page_tri,&p);

}



// ************************* Fonction hit des visiteurs *********************

void hit_des_visiteurs(Ligne*Visite,int *nb_ligne,int *tempo)
{
// declaration des variables

int b, i, j, k, l, v, comp, nb_visite;
char tmp;
tableau memoire;
Hit visiteur[maxi],visiteur_tri[maxi];

// initialisation des variables

memoire.nb=0; l=0; v=-1;
memoire.tab[l] =2000;


for(j=0;j<*nb_ligne-1;j++) // pour toute les lignes
{
while(j==memoire.tab[l]) // ces 2 lignes evitent de repeter
{ j++; l++;} // plusieurs fois la meme comparaison

v++; // pour passer au visiteur suivant
visiteur[v].nb=1; // nb de visite du visiteur n = 1
strcpy(visiteur[v].objet1,Visite[j].IP);
strcpy(visiteur[v].objet2," ");


for(i=j+1;i<*nb_ligne;i++)
{ // comparaison des IP de la ligne i et j
comp=strcmp(Visite[j].IP,Visite[i].IP);
if(comp==0)
{ // comparaison des sites
visiteur[v].nb++; // incrementation du nb de visites
// du visiteur v
// insertion de i dans memoire
insere(i,&memoire,&b);
if (b==0)
printf("\n\nERREUR!!!! tableau plein");

comp=strcmp(Visite[j].site,Visite[i].site);
if(comp==0)
{ // comparaison des dates
comp=strcmp(Visite[j].date,Visite[i].date);
if(comp==0)
{ // comparaison des heures
if(Visite[j].heure==Visite[i].heure)
{
comp=1;
// comparaison des minutes avec une marge de + … - 'tempo'
for(k=-*tempo;(k<=*tempo)&&(comp!=0);k++)
{
if(Visite[j].minutes==Visite[i].minutes+k)
comp=0;
}
// si toutes les comparaisons sont 'vraies' : on retire 1 a visiteur[v].nb
if(comp==0)
{
visiteur[v].nb--;
}}}}}}}

tri(&visiteur,&visiteur_tri,&v);

// ********************** affichage du Hit des Visiteurs ********************

clrscr();
gotoxy(16,12);
printf("Hit parade des Visiteurs par nombre de visites:\n");
fflush(stdin);
getchar();


affiche(&visiteur_tri,&v);

}



// ************************* Fonction hit des dates *************************

void hit_des_dates(Ligne*Visite,int *nb_ligne,int *tempo)
{
// declaration des variables

int b,d,i,j,k,l,m,n,comp,debut,fin;
Hit date[maxi];
Hit date_tri[maxi];
tableau memoire[maxi];

// initialisation des variables

comp=1;
d=0;
date[-1].nb=0;

for(j=0;j<*nb_ligne;j++)
{
date[d].nb=0;
i=j+1;
strcpy(date[d].objet1,Visite[j].date); // copie de la date de ligne j
strcpy(date[d].objet2," "); // dans la structure date[d]

do
{ // comparaison des dates de la ligne i et j
comp=strcmp(Visite[j].date,Visite[i].date);
date[d].nb++; // incrementation du nb de visite
i++; // pour la date d
}
while(comp==0); // tant que comp=0

d++; // d++ pour passer a la date suivante
debut=j; // j=i-2 permet de ne pas repeter
j=i-2; // l'operation pour les lignes deja trait‚es// l'operation pour les lignes deja trait‚es
l=0; // l=0 pour le tableau memoire
fin=j;

for(k=debut;k<fin;k++)
{
while(k==memoire[l].tab) // ces 2 lignes evitent de repeter
{ k++; l++; } // plusieurs fois la meme comparaison

for(m=k+1;m<fin;m++)
{ // comparaison des IP
comp=strcmp(Visite[m].IP,Visite[k].IP);
if(comp==0)
{ // comparaison des sites
comp=strcmp(Visite[m].site,Visite[k].site);
if(comp==0)
{ // comparaison des heures
if(Visite[m].heure==Visite[k].heure)
{
comp=1;
// comparaison des minutes avec une marge de + ou - 'tempo'
for(n=-*tempo;(n<=*tempo)&&(comp!=0);n++)
if(Visite[m].minutes==Visite[k].minutes+n)
comp=0;
// si toutes les comparaisons sont 'vraies' : on retire 1 a nb_visites
if(comp==0)
{
date[d-1].nb--;
/* on insere i dans memoir*/ insere(m,&memoire,&b);
if(b==0)
printf("\n\nERREUR!!!! tableau plein");
}}}}}}}

tri(&date,&date_tri,&d);

// ********************** affichage du Hit des Dates ************************

clrscr();
gotoxy(18,12);
printf("Hit parade des Dates par nombre de visites:\n");
fflush(stdin);
getchar();

affiche(&date_tri,&d);

}

////////////////////////////////////////////////////
Puis la bibliotheque

/***************************************************************************
* *
* BIBLIOTHEQUE *
* *
***************************************************************************/

#include<string.h>
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<math.h>
#define maxi 100



/*************************** Structure Hit ********************************

cette structure permet de classer le nombre de visite :
- par page
- par visiteur
- par date */

typedef struct { char objet1[50]; char objet2[50]; int nb; } Hit;

/************************** Structure tableau *****************************

cette structure permet de classer des ‚l‚ments correspondants a des
numeros de ligne dans un tableau.
cette structure est utilis‚e par la fonction insere. */

typedef struct { int tab[maxi];
int nb;
} tableau;

/************************* Fonction tri **********************************

cette fonction tri les Hits par ordre decroissant */

void tri(Hit *ligne,Hit *ligne_tri,int *K_max);

/************************* Fonction affichage ****************************

cette fonction affiche les Hits */

void affiche(Hit *ligne_tri,int *K_max);

/************************* Fonction Insere *******************************

cette fonction insere des ‚l‚ments de type entier dans un tableau
tri‚ par ordre croissant. */

void insere(int r,tableau *t,int *b);






// ************************** fonction insere *******************************

void insere(int r,tableau *t,int* b)
{
int i;

if ((*t).nb<maxi)
{
for(i=(*t).nb-1;i>=0&&(*t).tab[i]>r;i--)
(*t).tab[i+1]=(*t).tab[i];
(*t).tab[i+1]=r;
(*t).nb++;
*b=1;
}
else
*b=0;
}


void tri(Hit *ligne,Hit *ligne_tri,int *K_max)
{
int i=0, j, k, max=0;

for(j=0;j<*K_max;j++)
if(ligne[j].nb>max)
max=ligne[j].nb;

for(k=max;k>0;k--)
for(j=0;j<*K_max;j++)
if(ligne[j].nb==k)
{
strcpy(ligne_tri[i].objet1,ligne[j].objet1);
strcpy(ligne_tri[i].objet2,ligne[j].objet2);
ligne_tri[i].nb=ligne[j].nb;
i++;
}

}

void affiche(Hit *ligne_tri,int *K_max)

{
int i,j,k;


clrscr();

i=1; j=1;
for(k=0;k<*K_max;k++)
{
if(k>=12*i)
{
fflush(stdin);
getchar();
clrscr();
i++;
}
gotoxy(5,2*j);
printf("%s %s : ",ligne_tri[k].objet1,ligne_tri[k].objet2);

gotoxy(48,2*j);
j++;
if(j>12)
j=1;

if(ligne_tri[k].nb>1)
printf("%d visites\n",ligne_tri[k].nb);
else
printf("%d visite\n",ligne_tri[k].nb);
}
fflush(stdin);
getchar();
}

/////////////////////////////////////////////////////

Je comprend pas pourquoi il ne compte pas il me dit hit parrad 188 et quand je compile il me met null pointer ,je compile sous turbo C

J'espere que qqun pourra m''aider a r'esoudre les piti pb du prog :) :)