[Summary view] [Print] [Text view]

   1  #!/usr/bin/perl
   2  # SyncReplica.pl
   3  #
   4  # Auteur : Vincent MATHIEU. Université Nancy 2 CRI
   5  #          Vincent.Mathieu@univ-nancy2.fr
   6  # Version 2.0 Maj le 14 juin 2003
   7  #     passage de la librairie perldap de Mozilla vers la librairie Net::LDAP
   8  #     paramétrage de l'utilitaire plus 'convivial'
   9  #     meilleurs traitement des atributs administratifs
  10  #
  11  #
  12  # cet utilitaire controle les entrees LDAP d'un serveur LDAP maitre, et tente eventuellement de
  13  # mettre a jour un serveur LDAP esclave.
  14  #
  15  # il recoit les parametres suivants :
  16  # -master : obligatoire. le serveur maitre (ex : ldap.univ.fr, ou ldap.univ.fr:392 si autre port TCP)
  17  # -slave : obligatoire. le réplica (ex : ldap2.univ.fr, ou ldap2.univ.fr:392 si autre port TCP)
  18  # -basedn : obligatiore. le DN a partir duquel on travaille
  19  # -option : facultatif. 3 possibliltés :
  20  #           . anonymous . c'est l'option par défaut. dans ce cas, il y a exploration des 2 serveurs LDAP
  21  #                        et generation d'un message en cas de divergence d'existence d'entrees LDAP
  22  #           . only_pass . Il y a a controle de l'existence des entrées LDAP, et du password. Les paramètres ficmaster et ficslave sont alors obligatoires. il ya a MaJ du mot de passe dans l'esclave
  23  #           . full . Toutes les entrees sont comparees, avec tous les attributs. Les parametres ficmaster let ficslave sont obligatoires. il y a Maj de l'entrée esclave (ou suppression, si pas dans le maitre)
  24  # -bindmaster : c'est un fichier qui contient le DN et mot de passe associe pour lire toute information dans le LDAP maitre. Le fichier contient une ligne, constituee du DN, et du    mot de passe separes par le caractere ';'. 
  25  # -bindslave : itou ficmaster, pour le DN ayant le droit de replication sur l'esclave.
  26  #
  27  #la variable TousAttributs est eventuellement a personnaliser.
  28  #
  29  
  30  #use strict;
  31  use Net::LDAP;
  32  
  33  use vars qw(%DN1 %DN2 $BaseDN $Serv1 $Serv2 @TabOU  $Option $ErrAttrib @TousAttributs);
  34  use vars qw($Port1 $Port2 $CodeRetour $ErrLDAP $ErrGlob $nbTraite);
  35  use vars qw($bindMaster $bindSlave);
  36  
  37  $SIG{'ALRM'}  = 'ArretTimeout';
  38  
  39  {
  40    my ($NomFicErrs, $DNAdmin, $PassAdmin, $DN, $connLDAP1, $connLDAP2);
  41    my ($LaDate, $OU, $nbEntrees, $Tmp, $timeout, $mesg, $ind);
  42  
  43    $NomFicErrs = "/tmp/ErrReplica.txt";
  44    $timeout = 900;      # delai d'execution en secondes, avant erreur
  45    @TousAttributs = ['*', "structuralObjectClass", "entryUUID", "creatorsName", "createTimestamp",
  46                        "entryCSN", "modifiersName", "modifyTimestamp", "subschemaSubentry", "hasSubordinates"];
  47  
  48    alarm($timeout);
  49  
  50    $CodeRetour = 0;
  51    $DNAdmin = "";
  52    $PassAdmin = "";
  53    $nbTraite = 0;
  54    $Option = 0;
  55    $| = 1;       # flush le stdout
  56  
  57  #  ------ recuperation des parametres --------
  58    for ($ind = 0; $ind < scalar @ARGV; $ind++) 
  59    {
  60      if ($ARGV[$ind] eq "-master")
  61      {
  62        $ind++;
  63        ($Serv1, $Port1) = split(":", $ARGV[$ind]);
  64        $Port1 = 389 if ($Port1 eq "");
  65      }
  66      elsif ($ARGV[$ind] eq "-slave")
  67      {
  68        $ind++;
  69        ($Serv2, $Port2) = split(":", $ARGV[$ind]);
  70        $Port2 = 389 if ($Port2 eq "");
  71      }
  72      elsif ($ARGV[$ind] eq "-bindmaster")
  73      {
  74        $ind++;
  75        $bindMaster = $ARGV[$ind];
  76      }
  77      elsif ($ARGV[$ind] eq "-bindslave")
  78      {
  79        $ind++;
  80        $bindSlave = $ARGV[$ind];
  81      }
  82      elsif ($ARGV[$ind] eq "-basedn")
  83      {
  84        $ind++;
  85        $BaseDN = $ARGV[$ind];
  86      }
  87      elsif ($ARGV[$ind] eq "-option")
  88      {
  89        $ind++;
  90        my $opt = $ARGV[$ind];
  91        if ($opt eq "anonymous")
  92        {
  93          $Option = 0;
  94        }
  95        elsif($opt eq "only_pass")
  96        {
  97          $Option = 1;
  98        }
  99        elsif($opt eq "full")
 100        {
 101          $Option = 2;
 102        }
 103        else
 104        {
 105       &ErrSyntaxe();
 106        }
 107      }
 108    }
 109  
 110    &ErrSyntaxe() if (($Serv1 eq "") || ($Serv2 eq "") || ($BaseDN eq ""));
 111    &ErrSyntaxe() if (($Option > 0) && (($bindMaster eq "") || ($bindSlave eq "")));
 112    
 113    die "impossible de creer le fichier $NomFicErrs" if (! open(FICERR, ">$NomFicErrs"));
 114    $LaDate = GetDate();
 115  
 116    select FICERR;
 117    $| = 1;               # fichier vide a chaque ecriture
 118    select STDOUT;
 119  
 120    print FICERR "\t*** controle replica avec $Serv2:$Port2, le $LaDate ***\n\n";
 121    print FICERR "   Recherche rapide : entrees inexistantes ou en trop\n\n" if ($Option == 0);
 122    print FICERR "   Recherche rapide : entrees inexistantes ou en trop et mots de passe\n\n" if ($Option == 1);
 123    print FICERR "   Recherche complete\n\n" if ($Option == 2);
 124  
 125    if (! ($connLDAP2 = new Net::LDAP($Serv2, port => $Port2 )))
 126    {
 127      print FICERR "ERREUR. connexion LDAP refusee sur $Serv2:$Port2\n" ;
 128      exit 1;
 129    }
 130    if ($Option == 0)
 131    {
 132       $mesg = $connLDAP2->bind ();
 133    }
 134    else
 135    {
 136      &RecupAdmin($bindSlave, $DNAdmin, $PassAdmin);
 137      $mesg = $connLDAP2->bind ( dn => $DNAdmin, password  => $PassAdmin, version => 3 );
 138    }
 139    if ($mesg->is_error)
 140    {
 141      print FICERR "ERREUR. bind LDAP refuse sur $Serv2:$Port2 pour $DNAdmin\n" ;
 142      exit 1;
 143    } 
 144  
 145    $DNAdmin = $PassAdmin = "";
 146    if (! ($connLDAP1 = new Net::LDAP($Serv1, port => $Port1 )))
 147    {
 148      print FICERR "ERREUR. connexion LDAP refusee sur $Serv1:$Port1\n" ;
 149      exit 1;
 150    }
 151    if ($Option == 0)
 152    {
 153       $mesg = $connLDAP1->bind ();
 154    }
 155    else
 156    {
 157      &RecupAdmin($bindMaster, $DNAdmin, $PassAdmin);
 158      $mesg = $connLDAP1->bind ( dn => $DNAdmin, password  => $PassAdmin, version => 3 );
 159    }
 160    if ($mesg->is_error)
 161    {
 162      print FICERR "ERREUR. bind LDAP refuse sur $Serv1:$Port1 pour $DNAdmin\n" ;
 163      exit 1;
 164    } 
 165  
 166    if (! &GetOU(\$connLDAP1, $BaseDN))
 167    {
 168      print FICERR "ERREUR. $BaseDN n'existe pas sur $Serv1\n" ;
 169      exit 1;
 170    }
 171  
 172    foreach $OU (@TabOU)
 173    {
 174      print FICERR "Traitement de $OU\n" ;
 175      $nbEntrees = &TraiteOU(\$connLDAP1, \$connLDAP2, $OU);
 176      print FICERR "$OU : $nbEntrees entrees parcourues\n\n";
 177      
 178    }
 179    
 180    $connLDAP1->unbind;
 181    $connLDAP2->unbind;
 182    $LaDate = GetDate();
 183    print FICERR "\t*** Fin de traitement de $Serv2:$Port2, le $LaDate ***\n\n";
 184    exit $CodeRetour;
 185  }
 186  
 187  
 188  # traitement des entrees d'une OU
 189  # param 0 : pointeur sur handle de connexion LDAP
 190  # param 1 : pointeur sur handle de connexion LDAP
 191  # param 2 : OU de recherche
 192  sub TraiteOU
 193  {
 194    my ($OU, $DN, $nbEntrees, $Ret, $connLDAP1, $connLDAP2, $ListeAttrib, $nb2);
 195    $connLDAP1 = shift;
 196    $connLDAP2 = shift;
 197    $OU = shift;
 198    undef %DN1;
 199    undef %DN2;
 200    $nbEntrees = &RecupLDAP($connLDAP1, $OU, \%DN1);    # recup des DN de la branche du serveur 1
 201    if ($nbEntrees < 0)
 202    {
 203        $nbEntrees = - $nbEntrees;
 204        print FICERR "\nErreur $nbEntrees lors de lecture de $OU sur $Serv1 : $ErrLDAP\n";
 205        return -1;
 206    }
 207    $nb2 = &RecupLDAP($connLDAP2, $OU, \%DN2);    # recup des DN de la branche du serveur 2
 208    if ($nb2 < 0)
 209    {
 210        $nb2 = - $nb2;
 211        print FICERR "\nErreur $nb2 lors de lecture de $OU sur $Serv2 : $ErrLDAP\n";
 212        return -1;
 213    }
 214  
 215    foreach $DN (keys %DN1)    #  parcours des entrées de serveur 1
 216    {
 217      $nbTraite++;
 218      if (! defined($DN2{$DN}))
 219      {
 220        print FICERR "\n  ERREUR. DN $DN,$OU manque dans $Serv2:$Port2\n";
 221        $CodeRetour = 2;
 222        if ($Option != 0)   # pas anonyme
 223        {
 224          $Ret = &CreeEntree($connLDAP1, $connLDAP2, "$DN,$OU");
 225          if ($Ret)
 226          {
 227            print FICERR "    Creation de $DN,$OU OK dans $Serv2:$Port2\n";
 228          }
 229          else
 230          {
 231            print FICERR "    Creation de $DN,$OU impossible dans $Serv2:$Port2. $ErrGlob\n";
 232            $ErrGlob = "";
 233          }
 234        }
 235      }
 236      else   # les entrees existent dans les 2 serveurs. On les compare
 237      {
 238        if ($Option == 1)   # comparaison password
 239        {
 240          if ($DN1{$DN} ne $DN2{$DN})
 241          {
 242        $CodeRetour = 2;
 243            print FICERR "\n  ERREUR. Mot de passe different pour $DN,$OU\n";
 244            $Ret = &MajPassword($connLDAP2, "$DN,$OU", $DN1{$DN});
 245            if ($Ret)
 246            {
 247              print FICERR "    Mise a jour de $DN,$OU OK dans $Serv2:$Port2\n";
 248            }
 249            else
 250            {
 251              print FICERR "    Mise a jour de $DN,$OU impossible dans $Serv2:$Port2. $ErrGlob\n";
 252              $ErrGlob = "";
 253            }
 254          }
 255        }
 256        elsif ($Option == 2)   # comparaison totale
 257        {
 258          $Ret = &CompareDN($connLDAP1, $connLDAP2, "$DN,$OU", \$ListeAttrib);
 259          if ($Ret < 1)
 260          {
 261        $CodeRetour = 2;
 262            print FICERR "\n  ERREUR. Divergences avec $DN,$OU sur $ListeAttrib\n";
 263            if ($Ret == 0)
 264            {
 265              print FICERR "    Mise a jour de $DN,$OU OK dans $Serv2:$Port2\n";
 266            }
 267            else
 268            {
 269              print FICERR "    Mise a jour de $DN,$OU impossible dans $Serv2:$Port2. $ErrGlob\n";
 270              $ErrGlob = "";
 271            }
 272          }
 273        }
 274      }
 275      $DN2{$DN} = "1";
 276    }
 277    foreach $DN (keys %DN2)    # recherche des entrées dans serveur 2 pas dans serveur 1
 278    {
 279      if ($DN2{$DN} ne "1")
 280      {
 281        $CodeRetour = 2;
 282        print FICERR "  ERREUR. DN $DN,$OU en trop dans $Serv2:$Port2\n";
 283        if ($Option != 0)    # pas anonyme
 284        {
 285          $Ret = SupEntree($connLDAP2, "$DN,$OU");
 286          if ($Ret)
 287          {
 288            print FICERR "    Suppression de $DN,$OU OK dans $Serv2\n";
 289          }
 290          else
 291          {
 292            print FICERR "    Suppression de $DN,$OU impossible dans $Serv2. $ErrGlob\n";
 293            $ErrGlob = "";
 294          }
 295        }
 296      }
 297    }
 298    return $nbEntrees;
 299  }
 300  
 301  # comparaison de 2 entrees
 302  # param 0 : pointeur sur handle de connexion serveur1
 303  # param 1 : pointeur sur handle de connexion serveur2
 304  # param 2 : DN a comparer
 305  # param 3 : en retour : pointeur vers liste des attributs differents
 306  # retourne 1 si OK, 0 si different et repare, -1 si different et pas repare
 307  sub CompareDN
 308  {
 309    my($Entry1, $Entry2, $connLDAP1, $connLDAP2, $DN, $ListeAttrib, $mesg, $retour, %modAttribs);
 310    my($Attrib, $Nbre, $ind, %BadAttribs, $refTabAttrib1, $refTabAttrib2, $val1, $val2, $trouve);
 311    $connLDAP1 = shift;
 312    $connLDAP2 = shift;
 313    $DN = shift;
 314    $ListeAttrib = shift;
 315  
 316    $retour = 1;
 317    $mesg = $$connLDAP1->search(base => $DN, scope => "base", filter => "(objectclass=*)");
 318    return -1 if (($mesg->is_error) || ($mesg->count == 0));
 319    $Entry1 = $mesg->shift_entry;
 320    $mesg = $$connLDAP2->search(base => $DN, scope => "base", filter => "(objectclass=*)");
 321    return -1 if (($mesg->is_error) || ($mesg->count == 0));
 322    $Entry2 = $mesg->shift_entry;
 323         #----  on balaie tous les attributs de l'entree 1, et on marque ceux qui different -----
 324    foreach $Attrib ( $Entry1->attributes )
 325    {
 326      if (! $Entry2->exists($Attrib))
 327      {
 328        $refTabAttrib1 = $Entry1->get_value($Attrib, asref => 1);
 329        my @tabVal = @$refTabAttrib1;
 330        $modAttribs{$Attrib} = \@tabVal;
 331      }
 332      else
 333      {
 334        $refTabAttrib1 = $Entry1->get_value($Attrib, asref => 1);
 335        $refTabAttrib2 = $Entry2->get_value($Attrib, asref => 1);
 336        if (scalar @$refTabAttrib1 != scalar @$refTabAttrib2) # nombre de valeurs differents
 337        {
 338          my @tabVal = @$refTabAttrib1;
 339          $modAttribs{$Attrib} = \@tabVal;
 340        }
 341        else
 342        {
 343          $trouve = 0;
 344          foreach $val1 (@$refTabAttrib1)  # on balaie les valeurs de l'attribut
 345          {
 346            foreach $val2 (@$refTabAttrib2)  # on cherche equivalence  
 347            {
 348              if ($val1 eq $val2)
 349              {
 350                $trouve = 1;
 351                last;
 352          }
 353            }
 354            if (! $trouve)
 355            {
 356              my @tabVal = @$refTabAttrib1;
 357              $modAttribs{$Attrib} = \@tabVal;
 358        }
 359          }
 360        }
 361      }
 362    }
 363         #----  on cherche les attributs de l'entree 2 qui ne seraient pas dans entree 1 -----
 364    foreach $Attrib ( $Entry2->attributes )
 365    {
 366      if (! $Entry1->exists($Attrib))  # on vire dans entree2 si dans entree2 et pas entree1
 367      {
 368        my @tabVal;
 369        $modAttribs{$Attrib} = \@tabVal;
 370      }
 371    }
 372    if ((scalar keys %modAttribs) != 0)   #y a des modifs
 373    {
 374      $retour = 0;
 375      $$ListeAttrib = "";
 376      foreach $Attrib (keys %modAttribs)
 377      {
 378      $$ListeAttrib .= ", $Attrib";
 379      }
 380      $$ListeAttrib = substr($$ListeAttrib, 2);
 381      &MajAttribs($connLDAP2, $DN, \%modAttribs);
 382      #return -1 if (! &RemplaceEntree($connLDAP1, $connLDAP2, $DN ));
 383    }
 384    return $retour;
 385  }
 386  
 387  # MaJ du mot de passe
 388  # param 0 : pointeur sur handle de connexion serveur2
 389  # param 1 : DN a modifier
 390  # param 2 : le mot de passe
 391  sub MajPassword
 392  {
 393    my($Entry2, $connLDAP2, $DN, $Erreur, $NewPass, $mesg);
 394    $connLDAP2 = shift;
 395    $DN = shift;
 396    $NewPass = shift;
 397    return 1 if (($NewPass eq "") || ($NewPass eq "azerty"));
 398    $mesg = $$connLDAP2->search(base => $DN, scope => "base", filter => "(objectclass=*)",
 399                   attrs => 'userpassword');
 400    if (($mesg->is_error) || ($mesg->count == 0))
 401    {
 402      my $code = $mesg->code;
 403      my $message = $mesg->error;
 404      $ErrGlob = "erreur LDAP, code = $code : $message\n";
 405      return 0;
 406    }
 407    $Entry2 = $mesg->shift_entry;
 408  #  if ($Entry2->get_value('userpassword') eq "")   # pas la peine de tester. replace ajoute si existe pas
 409  #  {
 410  #      $mesg = $$connLDAP2->modify($DN, add => { 'userpassword' => $NewPass });
 411  #  }
 412  #  else
 413    $mesg = $$connLDAP2->modify($DN, replace => { 'userpassword' => $NewPass });
 414    if ($mesg->is_error)
 415    {
 416      my $code = $mesg->code;
 417      my $message = $mesg->error;
 418      $ErrGlob = "erreur LDAP, code = $code : $message\n";
 419      return 0; 
 420    }
 421    return 1;
 422  }
 423  
 424  
 425  
 426  # creation d'une entree du maitre vers le replica
 427  # param 0 : pointeur sur handle de connexion serveur1
 428  # param 1 : pointeur sur handle de connexion serveur2
 429  # param 2 : DN a creer
 430  sub CreeEntree
 431  {
 432    my($Entry, $connLDAP1, $connLDAP2, $DN, $mesg, $code, $message);
 433    $connLDAP1 = shift;
 434    $connLDAP2 = shift;
 435    $DN = shift;
 436  
 437    $mesg = $$connLDAP1->search(base => $DN, scope => "base", filter => "(objectclass=*)",
 438                   attrs => @TousAttributs);
 439    if (($mesg->is_error) || ($mesg->count == 0))
 440    {
 441      my $code = $mesg->code;
 442      my $message = $mesg->error;
 443      $ErrGlob = "erreur recup infos DN, code = $code : $message\n";
 444      return 0; 
 445    }
 446    $Entry = $mesg->shift_entry;
 447    $mesg = $$connLDAP2->add($Entry);
 448    if ($mesg->is_error)
 449    {
 450      my $code = $mesg->code;
 451      my $message = $mesg->error;
 452      $ErrGlob = "erreur creation DN, code = $code : $message\n";
 453      return 0; 
 454    }
 455    return 1;
 456  }
 457  
 458  # mise a jour d' attributs dans une entree LDAP locale
 459  # param 0 : pointeur sur handle de connexion LDAP
 460  # param 1 : DN a modifier
 461  # param 1 : pointeur sur un taleau associatif des attributs a modifier / creer / supprimer
 462  # retourne 1 si OK, 0 sinon
 463  sub MajAttribs
 464  {
 465    my ($connLDAP, $DN, $mesg, $modAttribs);
 466    $connLDAP = shift;
 467    $DN = shift;
 468    $modAttribs = shift;
 469  #  $modAttribs{n2atraliasmail}[0] = "vmathieu";  
 470  #  $modAttribs{n2atraliasmail}[1] = "Vincent.Mathieu";
 471  #  $modAttribs{n2atrpersannu} = "O";
 472  #  $modAttribs{n2atrpersras} = [];
 473    $mesg = $$connLDAP->modify($DN, replace => { %$modAttribs });
 474    if ($mesg->is_error)
 475    {
 476      my $code = $mesg->code;
 477      my $message = $mesg->error;
 478      $ErrGlob = "erreur creation DN, code = $code : $message\n";
 479      return 0; 
 480    }
 481    return 1;
 482  }
 483  
 484  # recopie d'une entree du maitre vers le replica
 485  # param 0 : pointeur sur handle de connexion serveur1
 486  # param 1 : pointeur sur handle de connexion serveur2
 487  # param 2 : DN a creer
 488  # !!!!!!! a priori, ne marche pas :
 489  # avec $Entry->update($$connLDAP2) : code = 82 : No attributes to update et rien dans log LDAP
 490  # avec $$connLDAP2->modify($Entry), il y a bien un MOD LDAP svec succes, mais pas de modif effective
 491  sub RemplaceEntree
 492  {
 493    my($Entry, $connLDAP1, $connLDAP2, $DN, $mesg, $code, $message);
 494    $connLDAP1 = shift;
 495    $connLDAP2 = shift;
 496    $DN = shift;
 497  
 498    $mesg = $$connLDAP1->search(base => $DN, scope => "base", filter => "(objectclass=*)",
 499                   attrs => @TousAttributs);
 500    if (($mesg->is_error) || ($mesg->count == 0))
 501    {
 502      $code = $mesg->code;
 503      $message = $mesg->error;
 504      $ErrGlob = "code = $code : $message";
 505      return 0;
 506    }
 507    $Entry = $mesg->shift_entry;
 508    printEntry(\$Entry);
 509  #  $mesg = $Entry->update($$connLDAP2);
 510    $mesg = $$connLDAP2->modify($Entry);
 511    if ($mesg->is_error)
 512    {
 513      my $code = $mesg->code;
 514      my $message = $mesg->error;
 515      $ErrGlob = "erreur modification DN, code = $code : $message";
 516      return 0; 
 517    }
 518    return 1;
 519  }
 520  
 521  
 522  # suppression d'une entree dans replica
 523  # param 0 : pointeur sur handle de connexion serveur2
 524  # param 2 : DN a supprimer
 525  sub SupEntree
 526  {
 527    my($Entry, $connLDAP2, $DN, $Erreur, $mesg);
 528    $connLDAP2 = shift;
 529    $DN = shift;
 530    $mesg = $$connLDAP2->delete($DN);
 531    if ($mesg->is_error)
 532    {
 533      my $code = $mesg->code;
 534      my $message = $mesg->error;
 535      $ErrGlob = "erreur LDAP, code = $code : $message\n";
 536      return 0; 
 537    }
 538    return 1;
 539  }
 540  
 541  # recherche des OU de l'arborescence
 542  # remplit le tableau @TabOU
 543  # param 0 : pointeur sur handle de connexion LDAP
 544  # param 1 : OU de recherche
 545  sub GetOU
 546  {
 547    my($Entry, $mesg, $connLDAP, $ind, $uneOU, $OU);
 548    $connLDAP = shift;
 549    $OU = shift;
 550    $mesg = $$connLDAP->search(base => $OU, scope => "sub", filter => "(objectclass=OrganizationalUnit)");
 551    return 0 if ($mesg->is_error);
 552    return 0 if ($mesg->count == 0);
 553    $ind = 0;
 554    foreach $Entry ($mesg->all_entries)
 555    {
 556      $uneOU = $Entry->dn();
 557      $uneOU =~ s/ //sg;
 558      $TabOU[$ind] = $uneOU;
 559      $ind++;
 560    }
 561    return $ind;
 562  }
 563  
 564  
 565  #                 recup des DN de l'OU passee en parametre
 566  # param 0 : pointeur sur Handle de connexion LDAP
 567  # param 1 : OU de recherche
 568  # param 2 : pointeur sur tableau associatif contenant les DN
 569  #  retourne le nombre d'entree, ou le code erreur en negatif  si erreur
 570  sub RecupLDAP
 571  {
 572    my($Entry, $DN, $connLDAP, $TabDN, $ind, $OU, $Serv, $Pass, $Err, $mesg);
 573  
 574    $connLDAP = shift;
 575    $OU = shift;
 576    $TabDN = shift;
 577    $ErrLDAP = "";
 578    $mesg = $$connLDAP->search(base => $OU, scope => "one", filter => "(!(objectclass=OrganizationalUnit))",
 579                               attrs => ['userpassword'] );
 580    if ($mesg->is_error)
 581    {
 582        $Err = $mesg->code;
 583        $ErrLDAP = $mesg->error;
 584        return - $Err;
 585    }
 586    return 0 if ($mesg->count == 0);  
 587    foreach $Entry ($mesg->all_entries)
 588    {
 589      $DN = $Entry->dn();
 590      $DN =~ s/ //sg;
 591      $DN =~ s/,$OU//i;
 592      $Pass = $Entry->get_value('userpassword');
 593      $Pass = "azerty" if ($Pass eq "");
 594      $$TabDN{$DN} = $Pass;
 595    }
 596    return $mesg->count;
 597  }
 598  
 599  # recuperation du DN et Password dans un fichier
 600  # param 0 : nom du fichier
 601  # param 1 : DN admin
 602  # param 2 : PASS admin
 603  sub RecupAdmin
 604  {
 605    my ($Ligne);
 606    if (! open(FICPASS, "<$_[0]"))
 607    {
 608      print FICERR "Impossible d'ouvrir $_[0]. connexion anonyme\n";
 609      return 0;
 610    }
 611    $Ligne = <FICPASS>;
 612    close FICPASS;
 613    chomp($Ligne);
 614    ($_[1], $_[2]) = split(";", $Ligne);
 615    if (($_[1] eq "") || ($_[2] eq ""))
 616    {
 617      $_[1] = ""; $_[2] = "";
 618      return 0;
 619    }
 620    return 1;
 621  }
 622  
 623  # ----------------------------------------------------------------------------
 624  # --            Fonction GetDate                                            --
 625  # retourne la date du jour en format JJ/MM/AAAA                              -
 626  # ----------------------------------------------------------------------------
 627  sub GetDate
 628  {
 629      my ($dateE, $an);
 630      my ($sec, $min, $heure, $mjour, $mois, $annee, $sjour, $ajour, $isdst) = localtime(time);
 631      $mois++;
 632      $an = 1900 + $annee;
 633      $mois = "0" . $mois if (length($mois) == 1);
 634      $mjour = "0" . $mjour if (length($mjour) == 1);
 635      $heure = "0" . $heure if (length($heure) == 1);
 636      $min = "0" . $min if (length($min) == 1);
 637      $dateE = "$mjour/$mois/$an - $heure:$min";
 638      return $dateE;
 639  }
 640  
 641  # ----------------------------------------------------------------------------
 642  # --            Fonction printEntry                                         --
 643  # --  sert au debugging                                                     -- 
 644  # --  imprime l'entree dont la reference est passee en parametre            --
 645  # --  usage :   &printEntry(\$Entry);                                       --
 646  # ----------------------------------------------------------------------------
 647  sub printEntry
 648  {
 649      my $Entry = shift;
 650      print "DN: ",$$Entry->dn,"\n";
 651      foreach my $attr ( sort $$Entry->attributes )
 652      {
 653          next if ( $attr =~ /;binary$/ );
 654          my $refTab = $$Entry->get_value($attr, asref => 1);
 655          foreach my $item (@$refTab)
 656          {
 657             print "  $attr : $item\n";
 658          }
 659      }
 660  }
 661  
 662  # ----------------------------------------------------------------------------
 663  # --            Fonction ErrSyntaxe                                         --
 664  # ----------------------------------------------------------------------------
 665  sub ErrSyntaxe
 666  {
 667      my $mess = shift;
 668      print "Erreur de syntaxe $mess\n\n";
 669      print "3 parametres obligatoires :\n";
 670      print "  . -master : le serveur LDAP maitre. si port <> 389, preciser celui-ci en fin de chaine. separateur = ':'\n";
 671      print "  . -slave : le serveur esclave. meme syntaxe\n";
 672      print "  . -basedn : le 'base DN' de l'operation\n";
 673      print "et 3 parametres facultatifs\n";
 674      print "  . -option. Peut prendre 3 valeurs :\n";
 675      print "       . anonymous. Option implicite. bind anonyme dans les 2 serveurs. Juste controle d'existence des entrees\n";
 676      print "       . only_pass. Controle et reparation des entrees inexistentes, ou mots de passe differents\n";
 677      print "       . full. Controle et reparation de la totalite\n";
 678      print "  . -bindmaster. nom d'un fichier qui contient le DN et mot de passe de bind dans le maitre\n";
 679      print "  . -bindslave. nom d'un fichier qui contient le DN et mot de passe de bind dans l'esclave\n";
 680      print "les 2 dernieres options sont necessaires si le parametre option est different d'anonymous\n\n";
 681      print "Un exemple :\n";
 682      print "SyncReplica.pl -master ldap.univ.fr:390 -slave ldap2.univ-nancy2.fr:392 -basedn dc=univ,dc=fr -bindmaster ./fic1 -bindslave ./fic2 -option full\n\n";
 683      exit 1;
 684  }
 685  
 686  
 687  # ----------------------------------------------------------------------------
 688  # --            Fonction ArreTimeout                                        --
 689  # --  cette fonction est appelee si le delai de timeout est depasse         -- 
 690  # ----------------------------------------------------------------------------
 691  sub ArretTimeout
 692  {
 693      my ($LaDate);
 694      $LaDate = GetDate();
 695      print FICERR "*********************************************************************\n";
 696      print FICERR "*   arret anormal de la procedure sur timeout                       *\n";
 697      print FICERR "*   arret a $LaDate                                     *\n";
 698      print FICERR "*   $nbTraite entrees parcourues au total                           *\n";
 699      print FICERR "*********************************************************************\n\n";
 700      exit 1;
 701  }