#!/usr/local/bin/perl

#
# 
# ###################################################################
#  boggia : Creation : 25/03/08
#  boggia : Modification : 28/04/08
#	    ajout des routines de creation des sondes nbassocwifi et 
#	    nbauthwifi pour la supervision des associations sur le
#	    reseau sans fil
#  boggia : Modification : 15/05/08
#	    simplification des messages d'erreur envoys par mails
#
# Script lanc de maniere priodique par Cron. 
# Permet de mettre  jour les bases et les sondes RRDTool de 
# l'application Metro
#
#

use SNMP_util;
use Socket;
use Sys::Syslog;                          # Misses setlogsock.
use Sys::Syslog qw(:DEFAULT setlogsock);  # Also gets setlogsock
use DBI;
use warnings;
use strict;

require "/usr/local/lib/netmagis/libmetro.pl";

# tunning du module SNMP pour ne pas afficher les erreurs sur la sortie
# standard en cas d'echec d'interrogation
$SNMP_Session::suppress_warnings = 2;
$SNMP_util::Debug = 0;

# lecture du fichier de configuration general
our $conf_file = "/usr/local/etc/netmagis.conf";
our %global_conf = read_global_conf_file($conf_file);

our %sensor_types = (
	'trafic'       		=> { 'graph'=>'trafic','rrd'=>'1','period'=>'*/5 * * * *','enabled'=>'1' },
	'trafic1min'		=> { 'graph'=>'trafic','rrd'=>'1','period'=>'* * * * *','enabled'=>'1' },
	'ifNom-snmp32'		=> { 'graph'=>'trafic','rrd'=>'1','period'=>'*/5 * * * *','enabled'=>'1' },
	'ifNom-snmp64'		=> { 'graph'=>'trafic','rrd'=>'1','period'=>'*/5 * * * *','enabled'=>'1' },
	'nbauthwifi'		=> { 'graph'=>'nbauthwifi','rrd'=>'1','period'=>'*/5 * * * *','enabled'=>'1' },
	'nbassocwifi'		=> { 'graph'=>'nbassocwifi','rrd'=>'1','period'=>'*/5 * * * *','enabled'=>'1' },
	'broadcast'		=> { 'graph'=>'broadcast','rrd'=>'1','period'=>'* * * * *','enabled'=>'1' },
	'multicast'		=> { 'graph'=>'multicast','rrd'=>'1','period'=>'* * * * *','enabled'=>'1' },
	'ipmac'			=> { 'graph'=>'ipmac','rrd'=>'1','period'=>'*/5 * * * *','enabled'=>'1' },
	'portmac.cisco'		=> { 'graph'=>'portmac','rrd'=>'0','period'=>'3,8,13,18,23,28,33,38,43,48,53,58 * * * *','enabled'=>'1' },
	'portmac.juniper'	=> { 'graph'=>'portmac','rrd'=>'0','period'=>'3,8,13,18,23,28,33,38,43,48,53,58 * * * *','enabled'=>'1' },
	'portmac.hp'		=> { 'graph'=>'portmac','rrd'=>'0','period'=>'3,8,13,18,23,28,33,38,43,48,53,58 * * * *','enabled'=>'1' },
);

# For special tunning for sensor types.
# To alter values of %sensor_type variable, you must create the following file
# and set %sensor_type fields.
if(-e "/usr/local/lib/netmagis/sensors-options.pl")
{
        require "/usr/local/lib/netmagis/sensors-options.pl";
}



# fichier de configuration principal et chargement des fonctions de base
our $datadir = $global_conf{metrodatadir};
our $sensorfile = $datadir . "/poller/metro.sensor";
our $quarantinefile = $datadir . "/poller/metro.quarantine";
our $lockdir = $datadir . "/lock";
our $cachedir = $datadir . "/cache";

# liste eq en supervision
our %sonde_sup_prod;
# liste eq integres dans appli TOPO
our %sonde_sup_new;
# liste des sondes de metrologie integree dans la supervision
our %sonde_majMETRO;
# liste des sondes de metrologie a integrer dans la supervision
our %sonde_maj_sonde;
# liste des sondes dont l'integration dans la supervision a echouee
our %sursis_maj_sondes;
# liste de quanrantaine pour les sondes suprimees
our %quarantaine;
# messages d'erreurs pour sortie mail
our %error_msg;
# fichier de cache pour les oids des equipements
our %oid_cache;

# heure de lancement du programme
our $timet = time;

# message envoye par mail
our $message_mail = 0;
our $entete_mail = "Mise  jour des POINTS de METROLOGIE\n
                    ------------------------------------\n\n";

#creation d'une socket syslog unix
setlogsock("unix");

writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
    "\t #######################################");
writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
    "\t Demarrage du programme de creation des bases RRD");

#opendir(REPLOCK,$lockdir);
#my @file_processing = grep(/update_metro/,readdir REPLOCK);
#closedir(REPLOCK);

# si la base n'est pas locke
if(check_lock_file($lockdir,"update_metro.lock","metrocreatedb") == 0)
{
    	# on locke tant que l'appli tourne
    	create_lock_file($lockdir,"update_metro.lock","metrocreatedb");

    	# create poller directory if not exists
    	if(not -d "$datadir/poller")
    	{	
    		create_directory("$datadir/poller","metrocreatedb",$global_conf{majdblogfacility});
    	}

    	# create rrd files directory if not exists
    	if(not -d "$datadir/rrddb")
    	{
		create_directory("$global_conf{'metrodatadir'}/rrddb","metrocreatedb",$global_conf{majdblogfacility});
    	}
	
    	# create cache directory
   	if(not -d $cachedir)
    	{
        	create_directory($cachedir,"metrocreatedb",$global_conf{majdblogfacility});
    	}

    	# chargement du cache des SysOid des equipements
    	load_oid_cache();

    	# chargement de la liste des sondes de metrologie en place
    	charger_liste_majMETRO();
    
    	# FIXME : INACTIVE
    	# chargement de la liste des equipements supervises dans la plateforme de supervision
    	# charger_liste_sup_prod();

	# chargement de la liste des nouvelles sondes
        #my $lecture_maj_sondes = charger_liste_maj_sondes();

    	# chargement de la liste des nouvelles sondes via la base DNS
    	my $lecture_maj_sondes = load_dns_sql_sensors();

    	# si le chargement de la liste des nouvelles sondes echoue.
    	if($lecture_maj_sondes == -1)
    	{
        	message_erreur("ERREUR : Liste des sondes envoye par TOPO vide => Aucune mise  jour.");

        	writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                        "\t ERREUR : sensor update file empty");
        	writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                        "\t Fin du programme ######################");
        	
		# suppression du verrou
        	delete_lock_file("$lockdir/update_metro.lock");
		
		# end of program
		exit(0);
    	}

    	# FIXME : INACTIF
    	## SUPERVISION
    	# installations des hotes supervises a partir de TOPO
    	# cmp_listes_hotes_supervises();
    	# ecriture du fichier des hostes supervises
    	# ecrit_liste_sup_eq();
    
    	## METROLOGIE
    	# suppression des sondes de metrologie perimees
    	test_bases_expirees();

	# create plugins portmac and ipmac for mac database
        enable_plugin_ipmac_portmac();

    	# creation ou suppression de sondes de metrologie
    	creeSupprSonde();

	read_tab_asso(%sonde_majMETRO);

	print "creeSupprSonde\n";

	ecrit_fichier_graph();

	print "ecrit_fichier_graph\n";

	write_oid_cache();

	print "write_oid_cache\n";

    	writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
    		"\t Fin du programme ######################");

    	# suppression du verrou
    	delete_lock_file("$lockdir/update_metro.lock");
}
else     
{             
    writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
        "\t Fichier lock dans $lockdir");
}

if($message_mail == 1)
{
    print "$entete_mail\n";
    foreach my $key (keys %error_msg)
    {
        print "$key\n";
    }
}


##################################################################################
# FONCTIONS ASSOCIEES
##################################################################################

##################################################################################
# creation suppression des sondes de metrologie
sub creeSupprSonde
{
    my $key;
    my $compteur_keys;
    my %sensor_disabled;
    my $sdis = 0;

    # liste toute les sondes envoyees par TOPO
    foreach $key (keys %sonde_maj_sonde)
    {
	# if sensor type not enabled
	if($sensor_types{$sonde_maj_sonde{$key}{type}}{enabled} == 0)
	{
		if(not exists $sensor_disabled{$sonde_maj_sonde{$key}{type}})
		{
			$sensor_disabled{$sonde_maj_sonde{$key}{type}} = 0;
			$sdis = 1;
		}
		
		$sensor_disabled{$sonde_maj_sonde{$key}{type}} ++;	
			
		next;		
	}

	$compteur_keys ++;
	# teste si la sonde existe dj dans la table majMETRO (mise a jour des sondes)
	if(defined($sonde_majMETRO{$key}))
	{
	    # remplacement des : dans les arguments par des espaces
            if($sonde_majMETRO{$key}{params} =~/:/)
            {
		$sonde_majMETRO{$key}{params} =~tr/:/ /;
            }
	
	    # ajustement de l'echantillonage en fonction 	
	    if($sensor_types{$sonde_maj_sonde{$key}{type}}{period} ne $sonde_majMETRO{$key}{period})
	    {
		if(defined $sensor_types{$sonde_maj_sonde{$key}{type}}{period})
		{
			$sonde_majMETRO{$key}{period} = $sensor_types{$sonde_maj_sonde{$key}{type}}{period};
		}
	    }

	    # la sonde existe deja. On regarde si les parametres ont change.
	    if($sonde_majMETRO{$key}{params} ne $sonde_maj_sonde{$key}{params}
		|| $sonde_majMETRO{$key}{ip} ne $sonde_maj_sonde{$key}{ip}
		|| $sonde_majMETRO{$key}{community} ne $sonde_maj_sonde{$key}{community}) 
	    {
		# les parametres de la sonde ont change, on met a jour.
		my $p1 = "$sonde_majMETRO{$key}{ip} $sonde_majMETRO{$key}{community} $sonde_majMETRO{$key}{params}";
		my $p2 = "$sonde_maj_sonde{$key}{ip} $sonde_maj_sonde{$key}{community} $sonde_maj_sonde{$key}{params}";

		if($p2!~/undef/)
		{
		    my $nom_pt_metro = get_nom_pt_metro($key);
		    message_erreur("MODIFICATION : point de metrologie \"$nom_pt_metro\". Nouveaux parametres ($p1) => ($p2)");
		}
		writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
		    "\t WARNING : sonde $compteur_keys, changement des parametres ($p1 != $p2)");
		
		ajouter_sonde($key,$sonde_maj_sonde{$key}{type},
                              $sonde_maj_sonde{$key}{ip},
                              $sonde_maj_sonde{$key}{community},
                              $sonde_maj_sonde{$key}{params});
	    }
	    else
	    {
		# les parametres n'ont pas change 
		# on teste l'existance de la base rrd
		if(-e $key)
		{
		    # operations specifiques aux sondes de trafic
		    if($sonde_maj_sonde{$key}{type} eq "trafic" || $sonde_maj_sonde{$key}{type} eq "trafic1min")
		    {
		    	# controle de la vitesse de l'interface par rapport a la sonde
		    	if(check_if_speed($sonde_majMETRO{$key}{type},
                                          $sonde_maj_sonde{$key}{ip},
                                          $sonde_maj_sonde{$key}{community},
                                          $sonde_maj_sonde{$key}{params}) == 1)
			{
				# la vitesse est ok, pas de mise a jour a effectuer.
                        	delete $sonde_maj_sonde{$key};	
			}
			else
			{
				# la vitesse n'est pas bonne, il faut mettre la sonde a jour				
				writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
		                        "\t WARNING : sonde $compteur_keys, changement du type de sonde pour $key");

                    		ajouter_sonde($key,$sonde_maj_sonde{$key}{type},
                                              $sonde_maj_sonde{$key}{ip},
                                              $sonde_maj_sonde{$key}{community},
                                              $sonde_maj_sonde{$key}{params});
			}
		    }
		    else
		    {
		    	# la sonde existe deja avec les bons parametres. Pas de mise a jour a effectuer.
                    	delete $sonde_maj_sonde{$key};
		    }
		}
		elsif($sensor_types{$sonde_maj_sonde{$key}{type}}{rrd} == 0)
		{
			# pas de base rrd associee.
			# la sonde existe deja avec les bons parametres. Pas de mise a jour.
			delete $sonde_maj_sonde{$key};
		}
		else
		{
		    # la sonde n'existe pas, il faut la creer.
		    my $nom_pt_metro = get_nom_pt_metro($key);
		    
		    message_erreur("NOUVEAU point de metrologie : \"$nom_pt_metro\". Parametres ($sonde_maj_sonde{$key}{ip},
				$sonde_maj_sonde{$key}{community},$sonde_maj_sonde{$key}{params})");
		    writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                        "\t WARNING : sonde $compteur_keys, la base $key n'existe pas, procedure d'ajout de sonde");

                    ajouter_sonde($key,$sonde_maj_sonde{$key}{type},
                                  $sonde_maj_sonde{$key}{ip},
                                  $sonde_maj_sonde{$key}{community},
                                  $sonde_maj_sonde{$key}{params});
		}
	    }
	}
	# new sensor
	else
	{
	    my $nom_pt_metro = get_nom_pt_metro($key);
	    
	    message_erreur("NOUVEAU point de metrologie : \"$nom_pt_metro\". Parametres ($sonde_maj_sonde{$key}{ip},
			$sonde_maj_sonde{$key}{community},$sonde_maj_sonde{$key}{params}), sonde $compteur_keys");
	    
	    writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                        "\t INFO : NOUVEAU point de metrologie : \"$nom_pt_metro\". Parametres ($sonde_maj_sonde{$key}{ip},
                        $sonde_maj_sonde{$key}{community},$sonde_maj_sonde{$key}{params}), sonde $compteur_keys");

	    ajouter_sonde($key,$sonde_maj_sonde{$key}{type},
                          $sonde_maj_sonde{$key}{ip},
                          $sonde_maj_sonde{$key}{community},
                          $sonde_maj_sonde{$key}{params});
	}
    }
  
    # if some sensor type are disabled, write warning log message.
    if($sdis == 1)
    {
           my $list = "";
           foreach my $s (%sensor_disabled)
           {
                $list = "$list (type = $s, $sensor_disabled{$s} sensors)";
           }

           writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
               "\t WARNING : The following sensors types are disabled :$list. 
               Set the global variable %sensor_type to enable them.");
    } 

 
    # tentatives d'criture des fichiers mis  jour
    my $essais = 5;
    my $ok = 0;
    while($essais > 0)
    {
	if(check_lock_file("$lockdir","update_sensors.lock","metrocreatedb") == 0)
	{
	    # on locke le fichier pour le mettre  jour
	    create_lock_file("$lockdir","update_sensors.lock","metrocreatedb");
	
	    # ecriture du fichier majMETRO mis  jour
	    ecrit_liste_majMETRO();

	    # ecriture du fichier metro.maj_sondes
            #ecrit_liste_maj_sondes();

	    # suppression du verrou
	    delete_lock_file("$lockdir/update_sensors.lock");

	    $essais = 0;
	    $ok = 1;
	}
	else
	{   
	    sleep(5);
	    $essais --;
	}	
    }

    if($ok == 0)
    {
        message_erreur("ERREUR : Problmes d'ecriture (lock) du fichier majMETRO. Mises  jour perdues.");

        writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
            "\t ERREUR : Problmes d'ecriture (lock) du fichier majMETRO. Mises  jour perdues");
    }
}


###########################################################
# chargement des lignes du fichier des equipements 
# supervises
# FIXME
sub charger_liste_sup_prod
{
    if(open(LISTE,$global_conf{SUP_EQ}))
    {
	 my $compteur = 0;
         while(<LISTE>)
         {
              chomp;
              my @l = split(/,/,$_);

              if(ctrl_ip($l[1]) == 1 && $l[2] ne "")
              {
                  # supprime les doublons
                  if(!defined($sonde_sup_prod{$l[0]}))
                  {
                        $sonde_sup_prod{$l[0]}{'ip'} = $l[1];
                        $sonde_sup_prod{$l[0]}{'snmp_com'} = $l[2];
                        $sonde_sup_prod{$l[0]}{'host_tmpl'} = $l[3];
                        $sonde_sup_prod{$l[0]}{'topo_enabled'} = $l[4];
                        $sonde_sup_prod{$l[0]}{'quarantine'} = $l[5];

			$compteur ++;
                  }
             }
         }
	 close(LISTE);
		
	 writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
            "\t INFO : chargement de la liste des equipemements supervises : $compteur equipements");
     }
     else
     {
	 writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
            "\t WARNING : echec ouverture du fichier $global_conf{SUP_EQ}");
     }	
}


###########################################################
# chargement des lignes du fichier majMETRO
sub charger_liste_majMETRO
{
    my $i;
    if(open(LISTE,$sensorfile))
    {
	my $compteur = 0;
	my $line;

	while($line = <LISTE>)
	{
	    my $period = "";
            if($line =~/(.+);(.+) (.+)/)
            {
           	($period,$line) = (split(/;/,$line))[0,1];
            }

            chomp $line;
            my @liste = split(/\s+/,$line);

	    # Traitement METRO
	   # if($liste[1]=~/(.+).rrd$/)
	   # {
		$sonde_majMETRO{$liste[1]}{type} = $liste[0];
		$sonde_majMETRO{$liste[1]}{ip} = $liste[2];
		$sonde_majMETRO{$liste[1]}{community} = $liste[3];
		$sonde_majMETRO{$liste[1]}{params} = $liste[4];
		$sonde_majMETRO{$liste[1]}{period} = $period;

		if($sensor_types{$sonde_majMETRO{$liste[1]}{type}}{rrd} == 1)
		{
			$sonde_majMETRO{$liste[1]}{graph} = $sensor_types{$sonde_majMETRO{$liste[1]}{type}}{graph};
		}
		else
		{
			$sonde_majMETRO{$liste[1]}{graph} = "none";
		}

		my $t_liste = @liste;
		for(my $i=5;$i<$t_liste;$i++)
		{
			$sonde_majMETRO{$liste[1]}{params} = "$sonde_majMETRO{$liste[1]}{params} $liste[$i]";
		}
		if($sonde_majMETRO{$liste[1]}{params} =~/:/)
		{
			$sonde_majMETRO{$liste[1]}{params} =~tr/:/ /;
		}
		$compteur ++;
	   # }
	}
	close(LISTE);
	
	writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
            "\t INFO : chargement des sondes de metrologie existantes : $compteur sondes");
    }
    else
    {
	message_erreur("WARNING : ouverture du fichier $sensorfile echouee");
	writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
	    "\t WARNING : ouverture du fichier $sensorfile echouee");
    }

    # DEBUG
    #read_tab_asso(%sonde_majMETRO);
}



###########################################################
# chargement des nouvelles sondes en activite dans la base 
# SQL de l'appli TOPO
sub load_dns_sql_sensors
{
    my ($sql,$cursor,$sensor,$type,$eq,$ip,$comm,$param1,$param2,$lastmod,$lastseen);

    my $compteur = -1;

    #ouverture de la base PSQL
    my $db =  DBI->connect("dbi:Pg:dbname=$global_conf{dnsdbname};host=$global_conf{'dnsdbhost'}",
		$global_conf{'dnsdbuser'}, $global_conf{'dnsdbpassword'});

    if($db)
    {
        writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                "\t -> INFO : Connexion a la base $global_conf{dnsdbname}");

	$sql = "SELECT * from topo.sensor 
		WHERE now() - lastseen < interval '7d'";

        $cursor = $db->prepare($sql);
        $cursor->execute;

        while( ($sensor,$type,$eq,$comm,$param1,$param2,$lastmod,$lastseen) = $cursor->fetchrow )
        {
	# |id    		| type   |      eq |  comm | iface     |   param    |   lastmod           |   lastseen          |
	# |---------------------+--------+---------+-------+-----------+------------+---------------------+---------------------|
 	# |Mefs-ce1.crih-efs    | trafic | efs-ce1 | o2get | ge-0/0/2  |            | 2010-11-09 22:35:06 | 2010-11-16 16:47:53 |
	   	my $ctrl_sensor = 1;

		### DEBUG 
		if($eq =~ /\.fr$/ || $eq =~ /\.eu$/ || $eq =~ /\.net$/ || $eq =~ /\.com$/)
		{
			$ip = getaddrbyhostname($eq);
		}
		elsif(ctrl_ip($eq) != 1)
		{
			$eq = "$eq\.$global_conf{'defaultdomain'}";
			$ip = getaddrbyhostname($eq);

			if(ctrl_ip($ip) != 1)
			{
				$ctrl_sensor = 0;

				writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                			"\t -> ERROR : Liste eq dans la base DNS 
					($sensor,$type,$eq,$comm,$param1,$param2,$lastmod,$lastseen) Arguments invalides.");
			}
		}
		else
		{
			$ip = $eq;
		}

		if($ctrl_sensor == 1)
		{
			if($sensor_types{$type}{rrd} == 1)
			{
				$sensor = "$global_conf{'metrodatadir'}/rrddb/$sensor.rrd";
        		}

	       	 	$sonde_maj_sonde{$sensor}{type} = $type;
			$sonde_maj_sonde{$sensor}{ip} = $ip;
			$sonde_maj_sonde{$sensor}{community} = $comm;
			if($param2 ne "")
			{
				$sonde_maj_sonde{$sensor}{params} = "$param1 $param2";
			}
			else
			{
				$sonde_maj_sonde{$sensor}{params} = $param1;
			}

			# equipements a superviser                
                        $sonde_sup_new{$ip}=$comm;

			$compteur ++;
		}
	}
	writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                       "\t -> INFO : $compteur equipements dans la base $global_conf{dnsdbname}");
    }
    else
    {
	writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                       "\t -> ERROR : Probleme de connexion a la base $global_conf{dnsdbname}");
	return $compteur;
    }
	
    return $compteur;
}


#############################################################
# synchronisation de la liste des host integres dans TOPO 
# et ceux integres dans la plateforme de supervision
sub cmp_listes_hotes_supervises
{
	# controle des hosts a partir de la liste des hosts en supervision
	foreach my $key (keys %sonde_sup_prod)
	{
		# teste si l'equipement est integre a TOPO
		if(defined($sonde_sup_new{$sonde_sup_prod{$key}{'ip'}}))
		{
			# si dans la liste de TOPO on controle les infos et on les met a jour
			update_sup_host($key,$sonde_sup_new{$sonde_sup_prod{$key}{'ip'}});
		}
		# si l'equipement n'est plus integre dans TOPO
		else
		{
			del_sup_host($key);
		}
	}

	# controle des hosts a partir du reste de la liste envoye par TOPO
	# il ne s'agit plus que de nouvelles machines non supervisees
	foreach my $key (keys %sonde_sup_new)
	{
		my $oid = check_host($key,$sonde_sup_new{$key});
		# le host repond
		if($oid != -1)
		{
			my $hostname = gethostnamebyaddr($key);
			
			# si la resolution dns fonctionne
			if($hostname ne "")
			{
				$oid_cache{$hostname} = $oid;
		        	# ecriture dans la liste des machines a superviser
				$sonde_sup_prod{$hostname}{'ip'} = $key;
				$sonde_sup_prod{$hostname}{'topo_enabled'} = 1;
                        	$sonde_sup_prod{$hostname}{'quarantine'} = 0;
                        	$sonde_sup_prod{$hostname}{'snmp_com'} = $sonde_sup_new{$key};
				$sonde_sup_prod{$hostname}{'oid'} = $oid;
		
				 writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                                        "\t INFO SUP : Intergration en supervision de ($key,$sonde_sup_new{$key})");
			}
			# sinon message d'erreur
			else
			{
				writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                                	"\t ERREUR SUP : Integration en supervision de ($key,$sonde_sup_new{$key}), echec resolution DNS");
			}
		}
		# le host ne repond pas en snmp
		else
		{
			writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                		"\t ERREUR SUP : Impossible d'integrer en supervision l'equipement ($key,$sonde_sup_new{$key})");	
		}
	}
}


###########################################################
# traitement des bases qui n'existent plus dans topo
sub test_bases_expirees
{
    if(check_lock_file($lockdir,"quarantaine.lock","metrocreatedb") == 0)
    {
	# on locke le fichier pour le lire
	create_lock_file($lockdir,"quarantaine.lock","metrocreatedb");

	# lecture des bases recement supprimes de topo
	open(QUA,$quarantinefile);
	while(<QUA>)
	{
	    chomp;
	    my ($base,$temps) = (split(/;/,$_))[0,1]; 
	    $quarantaine{$base} = $temps;		     
	}
	close(QUA);

	my $key;
	foreach $key (keys %sonde_majMETRO)
	{
	    # teste si la sonde existe toujours dans topo
	    if(defined($sonde_maj_sonde{$key}))
	    {
		if(defined($quarantaine{$key}))
		{
		    # la sonde existe dans topo et est en quarantaine. On la supprime de la quarantaine.
		    my $nom_pt_metro = get_nom_pt_metro($key);
		    message_erreur("REMISE en SERVICE : point de mtrologie \"$nom_pt_metro\".");
		    writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
			"\t INFO : retrait de $key du fichier de quarantaine");
		    
		    delete $quarantaine{$key};
		}
            }
            # la sonde n'existe plus dans topo
	    else
            {
		 my $seuil = $global_conf{sensorsurvival} * 24 * 3600;

                 # si la sonde n'est pas encore en quarentaine
                 if(!defined($quarantaine{$key}))
                 {
                 	# on l'insert
                        $quarantaine{$key} = $timet;
                 }

                 if($quarantaine{$key} == $timet)
                 {
                        my $nom_pt_metro = get_nom_pt_metro($key);	
			message_erreur("SUPPRESSION dans TOPO : point de mtrologie \"$nom_pt_metro\".");
                    	writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                        	"\t WARNING : La sonde sur la base $key n'existe plus dans Topo. Mise en quarantaine");
                 }
                 elsif($quarantaine{$key} + $seuil <= $timet)
                 {
                        my $nom_pt_metro = get_nom_pt_metro($key);
                        message_erreur("SUPPRESSION DEFINITIVE : point de mtrologie \"$nom_pt_metro\".");
                        writelog("cree-base-metro","","info",
                        	"\t WARNING : suppression dfinitive de $key");

                       	supprimer_base($key);
                        delete $quarantaine{$key};
                 }
	    }
        }

	# nettoyage du fichier de quarantaine
        foreach $key (keys %quarantaine)
        {
         	 if(!defined($sonde_majMETRO{$key}))
                 {
                 	delete $quarantaine{$key};
                 }
        }

	# reecriture du fichier de quarantaine	
	open(QUA,">$quarantinefile");
	foreach $key (keys %quarantaine)
	{
	    print QUA "$key;$quarantaine{$key}\n";
	}
	close(QUA);

	# suppression du verrou
        delete_lock_file("$lockdir/quarantaine.lock");
    }
    else
    {
	writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                        "\t WARNING : file $quarantinefile locked");
    }
}


###########################################################
# suppression du parametre communaute snmp pour les mails
sub supprimer_com_snmp
{
    my ($params) = @_;
    my $i;

    my @tab_params = split(/\s+/,$params);
    my $t_tab = @tab_params;   
    my $p = "";
 
    for($i=0;$i<$t_tab;$i++)
    {
	if($i != 1)
	{
	    $p = "$p $tab_params[$i]";
	}
    }

    return $p;    
}


###########################################################
# extrait le nom du point de metrologie
sub get_nom_pt_metro
{
    my ($rrd_db) = @_;

    my @liste_dir = split(/\//,$rrd_db);
    my $t_liste_dir = @liste_dir;

    $rrd_db = $liste_dir[$t_liste_dir -1];

    ($rrd_db) = (split(/\.rrd/,$rrd_db))[0];

    return $rrd_db;
}


###########################################################
# ecriture du fichier FILE_SUP_EQ
# FIXME corriger fonction pour adapation netmagis
sub ecrit_liste_sup_eq
{
    my $key;

    # ecriture des sondes qui n'ont pas pu etre installees
    if(open(LISTE,">$global_conf{SUP_EQ}"))
    {
	#print LISTE "HOSTNAME,HOST_IP_ADDRESS,SNMP_COMMUNITY,HOST_TEMPLATE,TOPO_ENABLED,QUARANTINE\n";

        foreach $key (keys %sonde_sup_prod)
        {
		if($sonde_sup_prod{$key}{'ip'} ne "" && $sonde_sup_prod{$key}{'snmp_com'} ne "")
		{
            		print LISTE "$key,$sonde_sup_prod{$key}{'ip'},$sonde_sup_prod{$key}{'snmp_com'},$sonde_sup_prod{$key}{'host_tmpl'},$sonde_sup_prod{$key}{'topo_enabled'},$sonde_sup_prod{$key}{'quarantine'}\n";
		}
        }

        close(LISTE);
        
	writelog("metrocreatedb","$global_conf{majdblogfacility}","info",
            "\t INFO SUP : Ecriture du fichier $global_conf{SUP_EQ}");
    }
    else
    {
        writelog("metrocreatedb","$global_conf{majdblogfacility}","info",
            "\t ERREUR SUP : ouverture du fichier $global_conf{SUP_EQ} en ecriture impossible");
    }
}


##############################################################
# suppression d'un host de la plateforme de supervision
sub del_sup_host
{
        my ($key) = @_;

        # si le host n'a pas depasse la periode de max de quarantaine ...
        if(($timet - ($global_conf{sensorsurvival} * 84600)) < $sonde_sup_prod{$key}{'quarantine'})
        {
                $sonde_sup_prod{$key}{'topo_enabled'} = 0;

                if($sonde_sup_prod{$key}{'quarantine'} != 0)
                {
			my %t = get_time($sonde_sup_prod{$key}{'quarantine'});

                        writelog("metrocreatedb","$global_conf{majdblogfacility}","info",
                                "\t INFO SUP : Host en quarantaine : $key, depuis le $t{MDAY}-$t{MON}-$t{YEAR}");
                }
        }
        # sinon, on supprime le host de la supervision
        else
        {
                writelog("metrocreatedb","$global_conf{majdblogfacility}","info",
                                "\t INFO SUP : suppression definitive de $key,$sonde_sup_prod{$key}");
                delete $sonde_sup_prod{$key};
        }
}


#############################################################
# ecriture des messages d'erreurs dans un tableau associatif
sub message_erreur
{   my ($msg_err) = @_;

    $message_mail = 1;
    $error_msg{$msg_err} = 1;
}


#############################################################
# Mise a jour des parametres d'un host dans la plateforme de 
# supervision
sub update_sup_host
{
        my ($host,$snmp_com) = @_;

	my $quarantine = 0;

        my $hostname = gethostnamebyaddr($sonde_sup_prod{$host}{'ip'});

        my $oid = check_host($sonde_sup_prod{$host}{'ip'},$snmp_com);

        # si la machine est declaree dans le DNS
        if($hostname ne "")
        {
                if($host eq $hostname)
                {
                        $sonde_sup_prod{$hostname}{'topo_enabled'} = 1;
                        $sonde_sup_prod{$hostname}{'snmp_com'} = $snmp_com;
                }
                else
                # si le nom du host a change
                {
                        $sonde_sup_prod{$hostname}{'ip'} = $sonde_sup_prod{$host}{'ip'};
                        $sonde_sup_prod{$hostname}{'snmp_com'} = $snmp_com;
                        $sonde_sup_prod{$hostname}{'topo_enabled'} = 1;
                        delete $sonde_sup_prod{$host};

                        writelog("metrocreatedb","$global_conf{majdblogfacility}","info",
                                        "\t WARNING SUP : le nom du host a change $host -> $hostname : suppression de $host");
                }
        }
        # si la machine n'est pas declaree ou que le DNS ne repond pas
        else
        {
                $sonde_sup_prod{$hostname}{'snmp_com'} = $snmp_com;
                $sonde_sup_prod{$hostname}{'topo_enabled'} = 1;
		$quarantine = 1;
        }

        if($oid != -1)
        {
                $sonde_sup_prod{$hostname}{'oid'} = $oid;
        }
        else
        {
                 writelog("metrocreatedb","$global_conf{majdblogfacility}","info",
                        "\t ERREUR SUP : echec SNMP get sysOID ($sonde_sup_prod{$hostname}{'ip'},$snmp_com), on laisse en supervision");
		$quarantine = 1;
        }

	# mise en quarantaine
	if($quarantine == 1 && $sonde_sup_prod{$host}{'quarantine'} == 0)
	{
		$sonde_sup_prod{$host}{'quarantine'} = $timet;
	}

	# si l'hote est en quarantaine on lance la fonction de suppression
	if($quarantine == 1)
	{
	   	del_sup_host($host);
	}
	# sinon on le sort de la quarantaine
	else
	{
		$sonde_sup_prod{$host}{'quarantine'} = 0;
	}

        # nettoyage de sonde_sup_new
        delete $sonde_sup_new{$sonde_sup_prod{$host}{'ip'}};
}

 
###########################################################
# ajouter une sonde 
# - trafic
# - nbauthwifi
# - nbassocwifi
# - broadcast
# - multicast
# - trafficError
# - ipmac
# - portmac
sub ajouter_sonde
{
    my ($base,$type,$ip,$com,$params) = @_;

    if($type eq "trafic" || $type eq "aggreg_trafic" || $type eq "trafic1min")
    {
	if($ip=~/([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/)
	{
	    #les paramtres sont justes
	    my $result = trafic($ip,$com,$params,$base,$type);
	    
	    # si l'interface n'existe pas, on supprime l'entree
	    if($result == 2)
	    {
		delete $sonde_maj_sonde{$base};
	    }
	}
	else
	{
	    if("$ip $com $params" !~/undef/)
            {
		    my $nom_pt_metro = get_nom_pt_metro($base);
		    message_erreur("ERREUR : Parametres ERRONES pour le point de METRO \"$nom_pt_metro\":
					 ($ip,$com,$params)");
	    }
	    writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
		"\t ERREUR Parametres de sonde ($base, $type) errones : ($ip $com $params)");
	    
	    delete  $sonde_maj_sonde{$base};
	}
    }
    elsif($type eq "broadcast" || $type eq "multicast" || $type eq "trafficError" || $type eq "broadcast1min")
    {
	if($ip=~/([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/)
        {
            #les paramtres sont justes
            my $result = traficPaquets($type,$ip,$com,$params,$base);

            # si l'interface n'existe pas, on supprime l'entree
            if($result == 2)
            {
                delete $sonde_maj_sonde{$base};
            }
	}
	else
	{
            if("$ip $com $params" !~/undef/)
            {
                    my $nom_pt_metro = get_nom_pt_metro($base);
                    message_erreur("ERREUR : Parametres ERRONES pour le point de METRO \"$nom_pt_metro\":
                                         ($ip,$com,$params)");
            }
            writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                "\t ERREUR Parametres de sonde ($base, $type) errones : ($ip $com $params)");

            delete  $sonde_maj_sonde{$base}; 
	}
    }
    elsif($type eq "nbassocwifi" || $type eq "nbauthwifi")
    {
	if("$ip $com $params" =~/^([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+) (.+) (.+) (.+)$/)
        {
            #les paramtres sont justes
	    my $result = authassocwifi($type,$1,$2,$3,$4,$base);
	}
        else
        {
            if("$ip $com $params"!~/undef/)
            {
		    my $nom_pt_metro = get_nom_pt_metro($base);
		    message_erreur("ERREUR : Paramtres ERRONES pour le point de METRO \"$nom_pt_metro\".  Parametres : ($ip $com $params)");
            }
            writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                "\t ERREUR Paramtres de sonde ($base,$type) errones : ($ip $com $params)");

            delete  $sonde_maj_sonde{$base};
        }
    }
    # check and install new ipmac probe
    elsif($type eq "ipmac")
    {
	if("$ip $com" =~/^([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+) (.+)$/)
	{
		print "ipmac($type,$1,$2,$base)\n";
	    my $result = ipmac($type,$1,$2,$base);
	}
	else
        {
            if("$ip $com"!~/undef/)
            {
                    my $nom_pt_metro = get_nom_pt_metro($base);
                    message_erreur("ERREUR : Paramtres ERRONES pour le point de METRO \"$nom_pt_metro\".  Parametres : ($ip $com)");
            }
            writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                "\t ERREUR Paramtres de sonde ($base,$type) errones : ($ip $com)");

            delete  $sonde_maj_sonde{$base};
        }
    }
    elsif($type =~ /^portmac.*/)
    {
        if("$ip $com $params" =~/^([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+) (.+) (.+) (.+)$/)
        {
            my $result = portmac($type,$1,$2,$3,$4,$base);
        }
        else
        {
            if("$ip $com $params"!~/undef/)
            {
                    my $nom_pt_metro = get_nom_pt_metro($base);
                    message_erreur("ERREUR : Paramtres ERRONES pour le point de METRO \"$nom_pt_metro\".  Parametres : ($ip $com)");
            }
            writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                "\t ERREUR Paramtres de sonde ($base,$type) errones : ($ip $com)");

            delete  $sonde_maj_sonde{$base};
        }
    }
}

###########################################################
# create plugin probe 
# error codes : 
# 0 ok
sub enable_plugin_ipmac_portmac
{
   	#select value from global.config where key='macactive'
   	my $db =  DBI->connect("dbi:Pg:dbname=$global_conf{dnsdbname};host=$global_conf{'dnsdbhost'}",
                $global_conf{'dnsdbuser'}, $global_conf{'dnsdbpassword'});
   	
	if($db)
   	{
       	
		writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
               		"\t -> INFO : Connect to $global_conf{dnsdbname} database. Read global.conf table.");

      		my $sql = "SELECT value from global.config 
               		WHERE key='macactive'";

       		my $cursor = $db->prepare($sql);
       		$cursor->execute;

       		my $value = $cursor->fetchrow; 
       
		if($value == 1)
       		{
   			# write portmac-plugin
   			$sonde_majMETRO{'plugin-portmac'}{type} = "plugin";
   			$sonde_majMETRO{'plugin-portmac'}{ip} = "x";
   			$sonde_majMETRO{'plugin-portmac'}{community} = "x";
   			$sonde_majMETRO{'plugin-portmac'}{params} = "";
   			$sonde_majMETRO{'plugin-portmac'}{period} = "*/5 * * * *";
   			$sonde_majMETRO{'plugin-portmac'}{graph} = "none";
   			# write ipmac-plugin
   			$sonde_majMETRO{'plugin-ipmac'}{type} = "plugin";
   			$sonde_majMETRO{'plugin-ipmac'}{ip} = "x";
   			$sonde_majMETRO{'plugin-ipmac'}{community} = "x";
   			$sonde_majMETRO{'plugin-ipmac'}{params} = "";
   			$sonde_majMETRO{'plugin-ipmac'}{period} = "*/5 * * * *";
   			$sonde_majMETRO{'plugin-ipmac'}{graph} = "none";

			writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                        	"\t -> INFO : Active the sessions data storage to mac database");
		}

   		return 0;		
     	}
     	else
     	{
		writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                        "\t -> ERROR : Connect to $global_conf{dnsdbname} failed.");
    	}
	
	return 1;
}


###########################################################
# create probe to get portmac/mac associations on switches 
# error codes : 
# 0 ok
# 1 equipment down
sub portmac
{
    my ($sonde,$ip,$com,$iflist,$vlanlist,$base) = @_;

    my $param = $com."@".$ip;

    # get snmp sysoid of the equipement
    my $oid = get_snmp_oid($param);

    # if equipment responds
    if($oid ne -1)
    {
	# write new line
	$sonde_majMETRO{$base}{type} = $sonde;
        $sonde_majMETRO{$base}{ip} = $ip;
        $sonde_majMETRO{$base}{community} = $com;
        $sonde_majMETRO{$base}{params} = "$iflist:$vlanlist";
	$sonde_majMETRO{$base}{period} = $sensor_types{$sonde}{period};
	
	# delete entry in table %sonde_maj_sonde
        delete $sonde_maj_sonde{$base};
    }
    else
    {
        my $nom_pt_metro = get_nom_pt_metro($base);
        message_erreur("ERREUR : Point de mtrologie \"$nom_pt_metro\". L'quipement $ip ne repond pas.");
        writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                    "\t ERREUR : L'quipement $ip ne repond pas");
        return 1;
    }

    return 0;	
}

###########################################################
# create probe to get ip/mac associations in arp 
# database
# error codes : 
# 0 ok
# 1 equipment down
sub ipmac
{
    my ($sonde,$ip,$com,$base) = @_;

    my $param = $com."@".$ip;

    # get snmp sysoid of the equipement
    my $oid = get_snmp_oid($param);

    # if equipment responds
    if($oid ne -1)
    {
	# write new line
	$sonde_majMETRO{$base}{type} = $sonde;
        $sonde_majMETRO{$base}{ip} = $ip;
        $sonde_majMETRO{$base}{community} = $com;
        $sonde_majMETRO{$base}{params} = "none";
	$sonde_majMETRO{$base}{period} = "*/5 * * * *";
	
	# delete entry in table %sonde_maj_sonde
        delete $sonde_maj_sonde{$base};

        if(-e $base)
        {
            writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                    "\t INFO : La base $base existe deja, on continue a s'en servir");
        }
        else
        {
            creeBaseNbGeneric($base,"*/5");

            writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                    "\t INFO : Creation de $base");
        }	
    }
    else
    {
        my $nom_pt_metro = get_nom_pt_metro($base);
        message_erreur("ERREUR : Point de mtrologie \"$nom_pt_metro\". L'quipement $ip ne repond pas.");
        writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                    "\t ERREUR : L'quipement $ip ne repond pas");
        return 1;
    }

    return 0;	
}


###########################################################
# cree une sonde pour compter les authentifications et les
# associations sur le resau WiFi
# codes erreur
# 0 ok
# 1 equipement down
sub authassocwifi
{
    my ($sonde,$ip,$com,$if,$ssid,$base) = @_;
    
    my $param = $com."@".$ip;
    
    # recupration de l'oid de l'equipement
    my $oid = get_snmp_oid($param);

    # si l'quipement rpond
    if($oid != -1)
    {
	# ecriture de la nouvelle ligne
        $sonde_majMETRO{$base}{type} = $sonde;
	$sonde_majMETRO{$base}{ip} = $ip;
	$sonde_majMETRO{$base}{community} = $com;
	$sonde_majMETRO{$base}{params} = "$if:$ssid";

        # suppression de l'enre du tableau $sonde_maj_sonde
        delete $sonde_maj_sonde{$base};

        # vrifier existance d'une base
        # elle n'existe pas : on la cre
        if(-e $base)
        {
            writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                    "\t INFO : La base $base existe deja, on continue a s'en servir");
        }
        else
        {
	    creeBaseAuthassocwifi($base,$ssid);   
             
	    writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                    "\t INFO : Creation de $base");
        }
	
    }
    else
    {
	my $nom_pt_metro = get_nom_pt_metro($base);
	message_erreur("ERREUR : Point de mtrologie \"$nom_pt_metro\". L'quipement $ip ne repond pas.");
        writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                    "\t ERREUR : L'quipement $ip ne repond pas");
        return 1;
    }
    
    return 0;
}




###########################################################
# controle le type de sonde de trafic
# compteur 32 bits ou compteur 64 bits
# 1 la sonde est ok
# 0 la vitesse de l'interface a change il faut modifier le
# compteur, il y a une erreur
sub check_if_speed
{
	my ($sonde,$ip,$com,$if) = @_;

    	if($sonde eq "ifNom-snmp32" || $sonde eq "ifNom-snmp64")
    	{
		my $snmp_param = $com."@".$ip;

		# recuperation de la vitesse de l'interface
            	my $speed = get_snmp_ifspeed($snmp_param,"",$if,$global_conf{majdblogfacility});

		if($sonde eq "ifNom-snmp32")
		{
			if($speed > 100000000)
			{
				return 0;
				# la vitesse n'est pas bonne, il faut mettre la sonde a jour
                               	writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                                       	"\t WARNING : $sonde inadapte a $speed");
			}
			else
			{
				return 1;
			}
		}
		elsif($sonde eq "ifNom-snmp64")
		{
			if($speed > 100000000)
                        {
                                return 1;
                        }
                        else
                        {
                                return 0;
				# la vitesse n'est pas bonne, il faut mettre la sonde a jour
                               	writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                                       	"\t WARNING : $sonde inadapte a $speed");
                        }
		}
		return 0;
	}
	return 0;
}


###########################################################
# cree une sonde de trafic
# codes erreur 
# 0 ok
# 1 equipement down
# 2 interface inexistanet
sub trafic
{
    my ($ip,$com,$if,$base,$graph) = @_;
    
    my $inverse = 0;
    my ($i,$speed,$sonde_polling);
    my $param = $com."@".$ip;
    
    chomp $if;
    my $interf = $if;

    #print "$ip,$com,$if\n";
    # interroger l'equipement
    if($if=~/^-/)
    {
        $inverse = 1;
        $if =~s/^-//;
    }

    # recupration de l'oid de l'equipement
    my $oid = get_snmp_oid($param);

    # si l'quipement rpond
    if($oid ne -1)
    {
	# recuperation de l'oid de l'interface
	my $index = get_snmp_ifindex($param,$if);
	
	if($index != -1)
	{
	    # recuperation de la vitesse de l'interface   
	    $speed = get_snmp_ifspeed($param,$index,$interf,$global_conf{majdblogfacility});	    

	    if($speed <= 100000000)
	    {
		$speed = 100000000;
		$sonde_polling = "ifNom-snmp32";
	    }
	    else
	    {
		$sonde_polling = "ifNom-snmp64";
	    }
    
	    # ecriture de la nouvelle ligne
	    $sonde_majMETRO{$base}{ip} = $ip;
	    $sonde_majMETRO{$base}{community} = $com; 
	    $sonde_majMETRO{$base}{params} = $interf;
	    $sonde_majMETRO{$base}{type} = $sonde_polling;

	    if($graph eq "trafic1min")
            {
        	$sonde_majMETRO{$base}{period} = "* * * * *";

                writelog("cree-base-metro","","info",
                "\t INFO : Base $base, chantillonage * * * * *");
            }
            else
            {
		$sonde_majMETRO{$base}{period} = "*/5 * * * *";
            }
	    
	    # suppression de l'en du tableau $sonde_maj_sonde
	    delete $sonde_maj_sonde{$base};
	    
	    # vrifier existance d'une base
	    # elle n'existe pas : on la cre
	    if(-e $base)
	    {
		my $nom_pt_metro = get_nom_pt_metro($base);
		message_erreur("MODIFICATION : point de metrologie \"$nom_pt_metro\". Vitesse de l'interface ($ip,$interf) passse a $speed");
		writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
		    "\t INFO : La base $base existe deja");
			
		setBaseMaxSpeed($base,$speed);
	    }
	    else
	    {
		creeBaseTrafic($base,$speed,$global_conf{majdblogfacility},$sonde_majMETRO{$base}{period});
		
		writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                    "\t INFO : Creation de $base");
	    }
	}
	else	
	{
	    my $nom_pt_metro = get_nom_pt_metro($base);
	    message_erreur("ERREUR : point de mtrologie \"$nom_pt_metro\". L'interface $if de $ip n'existe pas, suppression de l'entree.");
	    writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                    "\t ERREUR : L'interface $if de $ip n'existe pas, suppression de l'entree");
	    return 2;
	}
    }
    else
    {
	my $nom_pt_metro = get_nom_pt_metro($base);
	message_erreur("ERREUR : point de mtrologie \"$nom_pt_metro\". L'equipement $ip ne repond pas");
	writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                    "\t ERREUR : L'equipement $ip ne repond pas");
	return 1;
    }
    
    return 0;
}


###########################################################
# cree une sonde qui compte les paquets
# - Broadcast
# - Multicast
# - Erreurs sur l'interface
# codes erreur 
# 0 ok
# 1 equipement down
# 2 interface inexistanet
sub traficPaquets
{

    my ($typeSonde,$ip,$com,$if,$base) = @_;
    
    my $inverse = 0;
    my ($i,$speed,$sonde_polling);
    my $param = $com."@".$ip;
    
    chomp $if;
    my $interf = $if;

    if($if=~/^-/)
    {
        $inverse = 1;
        $if =~s/^-//;
    }

    # recupration de l'oid de l'equipement
    my $oid = get_snmp_oid($param);

    # si l'quipement rpond
    if($oid ne -1)
    {
	# recuperation de l'oid de l'interface
	my $index = get_snmp_ifindex($param,$if);
	
	if($index != -1)
	{
	    # ecriture de la nouvelle ligne
	    $sonde_majMETRO{$base}{ip} = $ip;
	    $sonde_majMETRO{$base}{community} = $com; 
	    $sonde_majMETRO{$base}{params} = $interf;
	    $sonde_majMETRO{$base}{type} = $typeSonde;
	    $sonde_majMETRO{$base}{graph} = $typeSonde;
	    $sonde_majMETRO{$base}{period} = "*/5 * * * *";
	    
	    writelog("cree-base-metro","","info",
              	"\t INFO : Base $base, type = $sonde_majMETRO{$base}{type}");
            if($typeSonde =~/(.*)1min$/)
            {
            	$sonde_majMETRO{$base}{period} = "* * * * *";
                $sonde_majMETRO{$base}{type} = $1;

                writelog("cree-base-metro","","info",
                	"\t INFO : Base $base, chantillonage * * * * *");
            }

	    # suppression de l'en du tableau $sonde_maj_sonde
	    delete $sonde_maj_sonde{$base};
	    
	    # vrifier existance d'une base
	    # elle n'existe pas : on la cre
	    if(-e $base)
	    {
		my $nom_pt_metro = get_nom_pt_metro($base);
		message_erreur("MODIFICATION : point de metrologie \"$nom_pt_metro\". Vitesse de l'interface ($ip,$interf) passse a $speed");
		writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
		    "\t INFO : La base $base existe deja");
	    }
	    else
	    {
		# creation de la base avec une limitation a 200.000.000 de paquets par seconde
		creeBaseBroadcast($base,"200000000",$sonde_majMETRO{$base}{period});
		
		writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                    "\t INFO : Creation de $base");
	    }
	}
	else	
	{
	    my $nom_pt_metro = get_nom_pt_metro($base);
	    message_erreur("ERREUR : point de mtrologie \"$nom_pt_metro\". L'interface $if de $ip n'existe pas, suppression de l'entree.");
	    writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                    "\t ERREUR : L'interface $if de $ip n'existe pas, suppression de l'entree");
	    return 2;
	}
    }
    else
    {
	my $nom_pt_metro = get_nom_pt_metro($base);
	message_erreur("ERREUR : point de mtrologie \"$nom_pt_metro\". L'equipement $ip ne repond pas");
	writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
                    "\t ERREUR : L'equipement $ip ne repond pas");
	return 1;
    }
    
    return 0;
}

###########################################################
# retourne le sysoid d'un quipement
sub get_snmp_oid
{
    my ($param) = @_;

    my @sys_oid = ();
    &snmpmapOID("oid","1.3.6.1.2.1.1.2.0");
    @sys_oid = &snmpget($param,"oid");
    if($sys_oid[0] ne "")
    {
	return $sys_oid[0];
    }
    else
    {
	return -1;
    }
}



###########################################################
# ecriture du fichier majMETRO mis  jour
sub ecrit_liste_majMETRO
{
    my $key;
    
    if(open(LISTE,">$sensorfile"))
    {
	foreach $key (keys %sonde_majMETRO)
	{
	    if($sonde_majMETRO{$key}{params} =~/\s+/)
	    {
		$sonde_majMETRO{$key}{params} =~ tr/ /:/;
	    }
   	    if($sonde_majMETRO{$key}{params} eq "none")
            {
		$sonde_majMETRO{$key}{params} = " ";	
	    }	
	    if(exists $sonde_majMETRO{$key}{period})
	    {
	    	if($sonde_majMETRO{$key}{period} ne "")
            	{
                	print LISTE "$sonde_majMETRO{$key}{period};$sonde_majMETRO{$key}{type} $key $sonde_majMETRO{$key}{ip} $sonde_majMETRO{$key}{community} $sonde_majMETRO{$key}{params}\n";
            	}
            	else
            	{
               		print LISTE "$sonde_majMETRO{$key}{type} $key $sonde_majMETRO{$key}{ip} $sonde_majMETRO{$key}{community} $sonde_majMETRO{$key}{params}\n";
            	}
	    }
	}
	close(LISTE);
        writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
            "\t INFO : Ecriture du fichier $sensorfile");
    }
    else
    {
        writelog("metrocreatedb",$global_conf{majdblogfacility},"info",
            "\t ERREUR : ouverture du fichier $sensorfile en ecriture impossible");
    }
}

###########################################################
# chargement du fichier de cache des sysoid des equipements
# supervises
sub load_oid_cache
{
        if(open(LISTE,"$cachedir/sysoid.cache"))
        {
                while(<LISTE>)
        	{
              		chomp;
                        my($host,$sysoid) = (split(/,/,$_))[0,1];
                        $oid_cache{$host} = $sysoid;
                }
                close(LISTE);
        }
        else
    	{
        	writelog("cree-base-metro","","info",
           	"\t ERREUR : echec ouverture du fichier $global_conf{majdblogfacility}/sysoid.cache");
    	}
}

###########################################################
# ecriture du fichier de cache des sysoid des equipements
sub write_oid_cache
{
    my $key;

    if(open(LISTE,">$cachedir/sysoid.cache"))
    {
        foreach $key (keys %oid_cache)
        {
                    print LISTE "$key,$oid_cache{$key}\n";
        }
        close(LISTE);

        writelog("cree-base-metro","","info",
            "\t INFO SUP : Ecriture du fichier $global_conf{majdblogfacility}/sysoid.cache");
    }
    else
    {
        writelog("cree-base-metro","","info",
            "\t ERREUR SUP : ouverture du fichier $global_conf{majdblogfacility}/sysoid.cache en ecriture impossible");
    }
}


################################################################
# write file metro.grah for graph descriptions
sub ecrit_fichier_graph
{
    my $file_graph = "$datadir/graph/metro.graph";
    my $file_graph_tmp = "/tmp/metro.graph";

    open(LISTE,">$file_graph_tmp.temp");
    foreach my $key (keys %sonde_majMETRO)
    {
                my $nom_pt_metro = get_nom_pt_metro($key);

        print LISTE "$nom_pt_metro;$sonde_majMETRO{$key}{graph};1;$key;\n";
    }
    close(LISTE);

    system("cp $file_graph $file_graph_tmp.old");
    system("cp $file_graph_tmp.temp $file_graph");
    unlink "$file_graph_tmp.temp";
}


###########################################################
# FIXME
# chargement des nouvelles sondes
sub charger_liste_maj_sondes
{
    # chargement de la liste des sondes de TOPO a partir su spool
    if(open(LISTE,$global_conf{FILE_METRO_UPDATE_PROBES}))
    {
        my $compteur = 0;

        while(<LISTE>)
        {
            chomp;
            if(/^(.+?);(.+?);(.+?);(.+?);(.+?)$/ && !/echec$/)
            {
                # traitement supervision
                if(ctrl_ip($3) == 1 && $4 ne "")
                {
                        $sonde_sup_new{$3}=$4;
                }

                # traitement appli METRO
                my $param = clean_var($5);
                # supprime les doublons
                # si la sonde n'existe pas alors on la cree
                if(!defined($sonde_maj_sonde{$2}))
                {
                    # traitement appli METRO
                    $sonde_maj_sonde{$2}{type} = $1;
                    $sonde_maj_sonde{$2}{ip} = $3;
                    $sonde_maj_sonde{$2}{community} = $4;
                    $sonde_maj_sonde{$2}{params} = $param;
                    $compteur ++;
                }
	        # si elle existe deja dans la nouvelle liste ...
                else
                {
                    if(!defined($sursis_maj_sondes{$2}))
                    {
                        # il y a un doublon dans les nouvelles sondes

                        if(     ($sonde_maj_sonde{$2}{ip} eq $3)
                                && ($sonde_maj_sonde{$2}{community} eq $4)
                                && ($sonde_maj_sonde{$2}{params} eq "$param")
                          )
                        {
                            # la sonde en doublon a exactement les memes parametres.
                            # on ignore
                        }
                        elsif(($sonde_maj_sonde{$2}{ip} !~/undef/) && ($3 !~/undef/))
                        {
                            # sinon, on alerte pour une intervention humaine
                            # a condition que l'@ ip de l'equipement ait ete trouvee

                            # suppression par securite de la communaute snmp pour ne pas l'afficher dans le mail
                            my $nom_pt_metro = get_nom_pt_metro($2);
                            message_erreur("ERREUR DOUBLON : point de mtrologie \"$nom_pt_metro\".
                                                Sonde prsente sur ($3 $param) et ($sonde_maj_sonde{$2}{ip} $sonde_maj_sonde{$2}{params})");
                            writelog("cree-base-metro","","info",
                                "\t ERREUR : Doublon. $2 : Sonde presente sur ($3 $4 $param) et
                                ($sonde_maj_sonde{$2}{ip} $sonde_maj_sonde{$2}{community} $sonde_maj_sonde{$2}{params})");
                        }
                    }
		                        else
                    {
                        # sinon on verifie s'il n'y a pas un probleme de communaute
                        # SNMP dans une sonde trouve en tte de fichier.
                        if(     ($sonde_maj_sonde{$2}{ip} eq $3)
                                && ($sonde_maj_sonde{$2}{params} eq $param)
                                && ($sonde_maj_sonde{$2}{community} ne $4))
                        {
                            $sonde_maj_sonde{$2}{community} = $4;

                        }
                    }
                }
            }
            elsif(/^(.+?);(.+?);(.+?);(.+?);(.+?);echec/)
            {
                my $param = clean_var($5);
                # il s'agit d'une sonde dont l'installation a echoue
                # lors du precedant passage
                if(!defined($sonde_maj_sonde{$2}))
                {
                    $sonde_maj_sonde{$2}{type} = $1;
                    $sonde_maj_sonde{$2}{ip} = $3;
                    $sonde_maj_sonde{$2}{community} = $4;
                    $sonde_maj_sonde{$2}{params} = $param;
                    $sursis_maj_sondes{$2} = 1;
                }
            }
        }
        close(LISTE);
        writelog("cree-base-metro","","info",
            "\t INFO : chargement des sondes  mettre  jour, $compteur sondes");

        if($compteur == 0)
        {
            return -1;
        }
    }
    else
    {
        writelog("cree-base-metro","","info",
            "\t ERREUR : echec ouverture du fichier $global_conf{FILE_METRO_UPDATE_PROBES}");

        return -1;
    }
    return 0;
}



###########################################################
# suppression d'une base
sub supprimer_base
{
    my ($base) = @_;

    delete $sonde_majMETRO{$base};
}


