tools/dsync-0.0/libdsync/compare.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: compare.cc,v 1.6 1999/12/26 06:59:00 jgg Exp $
   4 /* ######################################################################
   5
   6    Compare a file list with a local directory
   7
   8    The first step in the compare is to read the names of each entry
   9    in the local directory into ram. This list is the first step to
  10    creating a delete list. Next we begin scanning the file list, checking
  11    each entry against the dir contents, if a match is found it is removed
  12    from the dir list and then stat'd to verify against the file list
  13    contents. If no match is found then the entry is marked for download.
  14    When done the local directory in ram will only contain entries that
  15    need to be erased.
  16
  17    ##################################################################### */
  18                                                                         /*}}}*/
  19 // Include files                                                        /*{{{*/
  20 #ifdef __GNUG__
  21 #pragma implementation "dsync/compare.h"
  22 #endif
  23
  24 #include <dsync/compare.h>
  25 #include <dsync/error.h>
  26 #include <dsync/fileutl.h>
  27 #include <dsync/md5.h>
  28
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31 #include <unistd.h>
  32 #include <dirent.h>
  33 #include <utime.h>
  34 #include <stdio.h>
  35                                                                         /*}}}*/
  36
  37 // DirCompre::dsDirCompare - Constructor                                /*{{{*/
  38 // ---------------------------------------------------------------------
  39 /* */
  40 dsDirCompare::dsDirCompare() : IndexSize(0), IndexAlloc(0), Indexes(0),
  41                      NameAlloc(0), Names(0), Verify(true), HashLevel(Md5Date)
  42 {
  43    IndexAlloc = 1000;
  44    Indexes = (unsigned int *)malloc(sizeof(*Indexes)*IndexAlloc);
  45    NameAlloc = 4096*5;
  46    Names = (char *)malloc(sizeof(*Names)*NameAlloc);
  47    if (Names == 0 || Indexes == 0)
  48       _error->Error("Cannot allocate memory");
  49 }
  50                                                                         /*}}}*/
  51 // DirCompare::~dsDirCompare - Destructor                               /*{{{*/
  52 // ---------------------------------------------------------------------
  53 /* */
  54 dsDirCompare::~dsDirCompare()
  55 {
  56    free(Names);
  57    free(Indexes);
  58 }
  59                                                                         /*}}}*/
  60 // DirCompare::LoadDir - Load all the names in the directory            /*{{{*/
  61 // ---------------------------------------------------------------------
  62 /* Such in every name in the directory, we store them as a packed, indexed
  63    array of strings */
  64 bool dsDirCompare::LoadDir()
  65 {
  66    // Scan the directory
  67    DIR *DirSt = opendir(".");
  68    if (DirSt == 0)
  69       return _error->Errno("opendir","Unable to open directory %s",SafeGetCWD().c_str());
  70    struct dirent *Ent;
  71    IndexSize = 0;
  72    char *End = Names + 1;
  73    while ((Ent = readdir(DirSt)) != 0)
  74    {
  75       // Skip . and ..
  76       if (strcmp(Ent->d_name,".") == 0 ||
  77           strcmp(Ent->d_name,"..") == 0)
  78          continue;
  79
  80       // Grab some more bytes in the name allocation
  81       if ((unsigned)(NameAlloc - (End - Names)) <= strlen(Ent->d_name)+1)
  82       {
  83          unsigned long OldEnd = End - Names;
  84          char *New = (char *)realloc(Names,sizeof(*Names)*NameAlloc + 4*4096);
  85          if (New == 0)
  86          {
  87             closedir(DirSt);
  88             return _error->Error("Cannot allocate memory");
  89          }
  90
  91          Names = New;
  92          NameAlloc += 4*4096;
  93          End = Names + OldEnd;
  94       }
  95
  96       // Grab some more bytes in the index allocation
  97       if (IndexSize >= IndexAlloc)
  98       {
  99          unsigned int *New = (unsigned int *)realloc(Indexes,
 100                              sizeof(*Indexes)*IndexAlloc + 1000);
 101          if (New == 0)
 102          {
 103             closedir(DirSt);
 104             return _error->Error("Cannot allocate memory");
 105          }
 106
 107          Indexes = New;
 108          IndexAlloc += 4*4096;
 109       }
 110
 111       // Store it
 112       Indexes[IndexSize] = End - Names;
 113       IndexSize++;
 114       strcpy(End,Ent->d_name);
 115       End += strlen(End) + 1;
 116    }
 117
 118    closedir(DirSt);
 119    return true;
 120 }
 121                                                                         /*}}}*/
 122 // DirCompare::Process - Process the file list stream                   /*{{{*/
 123 // ---------------------------------------------------------------------
 124 /* This scans over the dirs from the IO and decides what to do with them */
 125 bool dsDirCompare::Process(string Base,dsFList::IO &IO)
 126 {
 127    // Setup the queues and store the current directory
 128    string StartDir = SafeGetCWD();
 129
 130    // Change to the base directory
 131    if (chdir(Base.c_str()) != 0)
 132       return _error->Errno("chdir","Could not change to %s",Base.c_str());
 133    Base = SafeGetCWD();
 134    this->Base = Base;
 135
 136    string CurDir;
 137    dsFList List;
 138    bool Missing = false;
 139    while (List.Step(IO) == true)
 140    {
 141       if (Visit(List,CurDir) == false)
 142          return false;
 143
 144       switch (List.Tag)
 145       {
 146          // Handle a forward directory reference
 147          case dsFList::tDirMarker:
 148          {
 149             // Ingore the root directory
 150             if (List.Entity->Name.empty() == true)
 151                continue;
 152
 153             char S[1024];
 154
 155             snprintf(S,sizeof(S),"%s%s",Base.c_str(),List.Entity->Name.c_str());
 156
 157             /* We change the path to be absolute for the benifit of the
 158                routines below */
 159             List.Entity->Name = S;
 160
 161             // Stat the marker dir
 162             struct stat St;
 163             bool Res;
 164             if (lstat(S,&St) != 0)
 165                Res = Fetch(List,string(),0);
 166             else
 167                Res = Fetch(List,string(),&St);
 168
 169             if (Res == false)
 170                return false;
 171             break;
 172          }
 173
 174          // Start a directory
 175          case dsFList::tDirStart:
 176          {
 177             if (DoDelete(CurDir) == false)
 178                return false;
 179             if (chdir(Base.c_str()) != 0)
 180                return _error->Errno("chdir","Could not change to %s",Base.c_str());
 181
 182             CurDir = List.Dir.Name;
 183             Missing = false;
 184             IndexSize = 0;
 185             if (List.Dir.Name.empty() == false)
 186             {
 187                /* Instead of erroring out we just mark them as missing and
 188                   do not re-stat. This is to support the verify mode, the
 189                   actual downloader should never get this. */
 190                if (chdir(List.Dir.Name.c_str()) != 0)
 191                {
 192                   if (Verify == false)
 193                      return _error->Errno("chdir","Unable to cd to %s%s.",Base.c_str(),List.Dir.Name.c_str());
 194                   Missing = true;
 195                }
 196             }
 197
 198             if (Missing == false)
 199                LoadDir();
 200             break;
 201          }
 202
 203          // Finalize the directory
 204          case dsFList::tDirEnd:
 205          {
 206             if (DoDelete(CurDir) == false)
 207                return false;
 208             IndexSize = 0;
 209             if (chdir(Base.c_str()) != 0)
 210                return _error->Errno("chdir","Could not change to %s",Base.c_str());
 211             break;
 212          }
 213       }
 214
 215       // We have some sort of normal entity
 216       if (List.Entity != 0 && List.Tag != dsFList::tDirMarker &&
 217           List.Tag != dsFList::tDirStart)
 218       {
 219          // See if it exists, if it does then stat it
 220          bool Res = true;
 221          if (Missing == true || DirExists(List.Entity->Name) == false)
 222             Res = Fetch(List,CurDir,0);
 223          else
 224          {
 225             struct stat St;
 226             if (lstat(List.Entity->Name.c_str(),&St) != 0)
 227                Res = Fetch(List,CurDir,0);
 228             else
 229                Res = Fetch(List,CurDir,&St);
 230          }
 231          if (Res == false)
 232             return false;
 233       }
 234
 235       // Fini
 236       if (List.Tag == dsFList::tTrailer)
 237       {
 238          if (DoDelete(CurDir) == false)
 239             return false;
 240          return true;
 241       }
 242    }
 243
 244    return false;
 245 }
 246                                                                         /*}}}*/
 247 // DirCompare::DoDelete - Delete files in the delete list               /*{{{*/
 248 // ---------------------------------------------------------------------
 249 /* The delete list is created by removing names that were found till only
 250    extra names remain */
 251 bool dsDirCompare::DoDelete(string Dir)
 252 {
 253    for (unsigned int I = 0; I != IndexSize; I++)
 254    {
 255       if (Indexes[I] == 0)
 256          continue;
 257       if (Delete(Dir,Names + Indexes[I]) == false)
 258          return false;
 259    }
 260
 261    return true;
 262 }
 263                                                                         /*}}}*/
 264 // DirCompare::Fetch - Fetch an entity                                  /*{{{*/
 265 // ---------------------------------------------------------------------
 266 /* This examins an entry to see what sort of fetch should be done. There
 267    are three sorts,
 268      New - There is no existing data
 269      Changed - There is existing data
 270      Meta - The data is fine but the timestamp/owner/perms might not be */
 271 bool dsDirCompare::Fetch(dsFList &List,string Dir,struct stat *St)
 272 {
 273    if (List.Tag != dsFList::tNormalFile && List.Tag != dsFList::tDirectory &&
 274        List.Tag != dsFList::tSymlink && List.Tag != dsFList::tDeviceSpecial &&
 275        List.Tag != dsFList::tDirMarker)
 276       return _error->Error("dsDirCompare::Fetch called for an entity "
 277                            "that it does not understand");
 278
 279    // This is a new entitiy
 280    if (St == 0)
 281       return GetNew(List,Dir);
 282
 283    /* Check the types for a mis-match, if they do not match then
 284       we have to erase the entity and get a new one */
 285    if ((S_ISREG(St->st_mode) != 0 && List.Tag != dsFList::tNormalFile) ||
 286        (S_ISDIR(St->st_mode) != 0 && (List.Tag != dsFList::tDirectory &&
 287                                       List.Tag != dsFList::tDirMarker)) ||
 288        (S_ISLNK(St->st_mode) != 0 && List.Tag != dsFList::tSymlink) ||
 289        ((S_ISCHR(St->st_mode) != 0 || S_ISBLK(St->st_mode) != 0 ||
 290          S_ISFIFO(St->st_mode) != 0) && List.Tag != dsFList::tDeviceSpecial))
 291    {
 292       return Delete(Dir,List.Entity->Name.c_str(),true) && GetNew(List,Dir);
 293    }
 294
 295    // First we check permissions and mod time
 296    bool ModTime = (signed)(List.Entity->ModTime + List.Head.Epoch) == St->st_mtime;
 297    bool Perm = true;
 298    if ((List.Head.Flags[List.Tag] & dsFList::DirEntity::FlPerm) != 0)
 299       Perm = List.Entity->Permissions == (unsigned)(St->st_mode & ~S_IFMT);
 300
 301    // Normal file
 302    if (List.Tag == dsFList::tNormalFile)
 303    {
 304       // Size mismatch is an immedate fail
 305       if (List.NFile.Size != (unsigned)St->st_size)
 306          return GetChanged(List,Dir);
 307
 308       // Try to check the stored MD5
 309       if (HashLevel == Md5Always ||
 310           (HashLevel == Md5Date && ModTime == false))
 311       {
 312          if ((List.Head.Flags[List.Tag] & dsFList::NormalFile::FlMD5) != 0)
 313          {
 314             if (CheckHash(List,Dir,List.NFile.MD5) == true)
 315                return FixMeta(List,Dir,*St);
 316             else
 317                return GetChanged(List,Dir);
 318          }
 319       }
 320
 321       // Look at the modification time
 322       if (ModTime == true)
 323          return FixMeta(List,Dir,*St);
 324       return GetChanged(List,Dir);
 325    }
 326
 327    // Check symlinks
 328    if (List.Tag == dsFList::tSymlink)
 329    {
 330       char Buf[1024];
 331       int Res = readlink(List.Entity->Name.c_str(),Buf,sizeof(Buf));
 332       if (Res > 0)
 333          Buf[Res] = 0;
 334
 335       // Link is invalid
 336       if (Res < 0 || List.SLink.To != Buf)
 337          return GetNew(List,Dir);
 338
 339       return FixMeta(List,Dir,*St);
 340    }
 341
 342    // Check directories and dev special files
 343    if (List.Tag == dsFList::tDirectory || List.Tag == dsFList::tDeviceSpecial ||
 344        List.Tag == dsFList::tDirMarker)
 345       return FixMeta(List,Dir,*St);
 346
 347    return true;
 348 }
 349                                                                         /*}}}*/
 350 // DirCompare::DirExists - See if the entry exists in our dir table     /*{{{*/
 351 // ---------------------------------------------------------------------
 352 /* We look at the dir table for one that exists */
 353 bool dsDirCompare::DirExists(string Name)
 354 {
 355    for (unsigned int I = 0; I != IndexSize; I++)
 356    {
 357       if (Indexes[I] == 0)
 358          continue;
 359       if (Name == Names + Indexes[I])
 360       {
 361          Indexes[I] = 0;
 362          return true;
 363       }
 364    }
 365    return false;
 366 }
 367                                                                         /*}}}*/
 368 // DirCompare::CheckHash - Check the MD5 of a entity                    /*{{{*/
 369 // ---------------------------------------------------------------------
 370 /* This is invoked to see of the local file we have is the file the remote
 371    says we should have. */
 372 bool dsDirCompare::CheckHash(dsFList &List,string Dir,unsigned char MD5[16])
 373 {
 374    // Open the file
 375    MD5Summation Sum;
 376    FileFd Fd(List.Entity->Name,FileFd::ReadOnly);
 377    if (_error->PendingError() == true)
 378       return _error->Error("MD5 generation failed for %s%s",Dir.c_str(),
 379                            List.Entity->Name.c_str());
 380
 381    if (Sum.AddFD(Fd.Fd(),Fd.Size()) == false)
 382       return _error->Error("MD5 generation failed for %s%s",Dir.c_str(),
 383                            List.Entity->Name.c_str());
 384
 385    unsigned char MyMD5[16];
 386    Sum.Result().Value(MyMD5);
 387
 388    return memcmp(MD5,MyMD5,sizeof(MyMD5)) == 0;
 389 }
 390                                                                         /*}}}*/
 391 // DirCompare::FixMeta - Fix timestamps, ownership and permissions      /*{{{*/
 392 // ---------------------------------------------------------------------
 393 /* This checks if it is necessary to correct the timestamps, ownership and
 394    permissions of an entity */
 395 bool dsDirCompare::FixMeta(dsFList &List,string Dir,struct stat &St)
 396 {
 397    // Check the mod time
 398    if (List.Tag != dsFList::tSymlink)
 399    {
 400       if ((signed)(List.Entity->ModTime + List.Head.Epoch) != St.st_mtime)
 401          if (SetTime(List,Dir) == false)
 402             return false;
 403
 404       // Check the permissions
 405       if ((List.Head.Flags[List.Tag] & dsFList::DirEntity::FlPerm) != 0)
 406       {
 407          if (List.Entity->Permissions != (St.st_mode & ~S_IFMT))
 408             if (SetPerm(List,Dir) == false)
 409                return false;
 410       }
 411    }
 412
 413    return true;
 414 }
 415                                                                         /*}}}*/
 416
 417 // DirCorrect::GetNew - Create a new entry                              /*{{{*/
 418 // ---------------------------------------------------------------------
 419 /* We cannot create files but we do generate everything else. */
 420 bool dsDirCorrect::GetNew(dsFList &List,string Dir)
 421 {
 422    if (List.Tag == dsFList::tDirectory)
 423    {
 424       unsigned long PermDir = 0666;
 425       if ((List.Head.Flags[List.Tag] & dsFList::DirEntity::FlPerm) != 0)
 426          PermDir = List.Entity->Permissions;
 427
 428       if (mkdir(List.Entity->Name.c_str(),PermDir) != 0)
 429          return _error->Errno("mkdir","Unable to create directory, %s%s",
 430                               Dir.c_str(),List.Entity->Name.c_str());
 431
 432       // Stat the newly created file for FixMeta's benifit
 433       struct stat St;
 434       if (lstat(List.Entity->Name.c_str(),&St) != 0)
 435          return _error->Errno("stat","Unable to stat directory, %s%s",
 436                               Dir.c_str(),List.Entity->Name.c_str());
 437
 438       return FixMeta(List,Dir,St);
 439    }
 440
 441    if (List.Tag == dsFList::tSymlink)
 442    {
 443       if (symlink(List.SLink.To.c_str(),List.Entity->Name.c_str()) != 0)
 444          return _error->Errno("symlink","Unable to create symlink, %s%s",
 445                               Dir.c_str(),List.Entity->Name.c_str());
 446
 447       // Stat the newly created file for FixMeta's benifit
 448       struct stat St;
 449       if (lstat(List.Entity->Name.c_str(),&St) != 0)
 450          return _error->Errno("stat","Unable to stat directory, %s%s",
 451                               Dir.c_str(),List.Entity->Name.c_str());
 452
 453       return FixMeta(List,Dir,St);
 454    }
 455
 456    if (List.Tag == dsFList::tDeviceSpecial)
 457    {
 458       unsigned long PermDev;
 459       if ((List.Head.Flags[List.Tag] & dsFList::DirEntity::FlPerm) != 0)
 460          PermDev = List.Entity->Permissions;
 461       else
 462          return _error->Error("Corrupted file list");
 463
 464       if (mknod(List.Entity->Name.c_str(),PermDev,List.DevSpecial.Dev) != 0)
 465          return _error->Errno("mkdir","Unable to create directory, %s%s",
 466                               Dir.c_str(),List.Entity->Name.c_str());
 467
 468       // Stat the newly created file for FixMeta's benifit
 469       struct stat St;
 470       if (lstat(List.Entity->Name.c_str(),&St) != 0)
 471          return _error->Errno("stat","Unable to stat directory, %s%s",
 472                               Dir.c_str(),List.Entity->Name.c_str());
 473       return FixMeta(List,Dir,St);
 474    }
 475 }
 476                                                                         /*}}}*/
 477 // DirCorrect::DirUnlink - Unlink a directory                           /*{{{*/
 478 // ---------------------------------------------------------------------
 479 /* This just recursively unlinks stuff */
 480 bool dsDirCorrect::DirUnlink(const char *Path)
 481 {
 482    // Record what dir we were in
 483    struct stat Dir;
 484    if (lstat(".",&Dir) != 0)
 485       return _error->Errno("lstat","Unable to stat .!");
 486
 487    if (chdir(Path) != 0)
 488       return _error->Errno("chdir","Unable to change to %s",Path);
 489
 490    // Scan the directory
 491    DIR *DirSt = opendir(".");
 492    if (DirSt == 0)
 493    {
 494       chdir("..");
 495       return _error->Errno("opendir","Unable to open directory %s",Path);
 496    }
 497
 498    // Erase this directory
 499    struct dirent *Ent;
 500    while ((Ent = readdir(DirSt)) != 0)
 501    {
 502       // Skip . and ..
 503       if (strcmp(Ent->d_name,".") == 0 ||
 504           strcmp(Ent->d_name,"..") == 0)
 505          continue;
 506
 507       struct stat St;
 508       if (lstat(Ent->d_name,&St) != 0)
 509          return _error->Errno("stat","Unable to stat %s",Ent->d_name);
 510       if (S_ISDIR(St.st_mode) == 0)
 511       {
 512          // Try to unlink the file
 513          if (unlink(Ent->d_name) != 0)
 514          {
 515             chdir("..");
 516             return _error->Errno("unlink","Unable to remove file %s",Ent->d_name);
 517          }
 518       }
 519       else
 520       {
 521          if (DirUnlink(Ent->d_name) == false)
 522          {
 523             chdir("..");
 524             closedir(DirSt);
 525             return false;
 526          }
 527       }
 528    }
 529    closedir(DirSt);
 530    chdir("..");
 531
 532    /* Make sure someone didn't screw with the directory layout while we
 533       were erasing */
 534    struct stat Dir2;
 535    if (lstat(".",&Dir2) != 0)
 536       return _error->Errno("lstat","Unable to stat .!");
 537    if (Dir2.st_ino != Dir.st_ino || Dir2.st_dev != Dir.st_dev)
 538       return _error->Error("Hey! Someone is fiddling with the dir tree as I erase it!");
 539
 540    if (rmdir(Path) != 0)
 541       return _error->Errno("rmdir","Unable to remove directory %s",Ent->d_name);
 542
 543    return true;
 544 }
 545                                                                         /*}}}*/
 546 // DirCorrect::Delete - Delete an entry                                 /*{{{*/
 547 // ---------------------------------------------------------------------
 548 /* This obliterates an entity - recursively, use with caution. */
 549 bool dsDirCorrect::Delete(string Dir,const char *Name,bool Now)
 550 {
 551    struct stat St;
 552    if (lstat(Name,&St) != 0)
 553       return _error->Errno("stat","Unable to stat %s%s",Dir.c_str(),Name);
 554
 555    if (S_ISDIR(St.st_mode) == 0)
 556    {
 557       if (unlink(Name) != 0)
 558          return _error->Errno("unlink","Unable to remove %s%s",Dir.c_str(),Name);
 559    }
 560    else
 561    {
 562       if (DirUnlink(Name) == false)
 563          return _error->Error("Unable to erase directory %s%s",Dir.c_str(),Name);
 564    }
 565    return true;
 566 }
 567                                                                         /*}}}*/
 568 // DirCorrect::GetChanged - Get a changed entry                         /*{{{*/
 569 // ---------------------------------------------------------------------
 570 /* This is only called for normal files, we cannot do anything here. */
 571 bool dsDirCorrect::GetChanged(dsFList &List,string Dir)
 572 {
 573    return true;
 574 }
 575                                                                         /*}}}*/
 576 // DirCorrect::SetTime - Change the timestamp                           /*{{{*/
 577 // ---------------------------------------------------------------------
 578 /* This fixes the mod time of the file */
 579 bool dsDirCorrect::SetTime(dsFList &List,string Dir)
 580 {
 581    struct utimbuf Time;
 582    Time.actime = Time.modtime = List.Entity->ModTime + List.Head.Epoch;
 583    if (utime(List.Entity->Name.c_str(),&Time) != 0)
 584       return _error->Errno("utimes","Unable to change mod time for %s%s",
 585                            Dir.c_str(),List.Entity->Name.c_str());
 586    return true;
 587 }
 588                                                                         /*}}}*/
 589 // DirCorrect::SetPerm - Change the permissions                         /*{{{*/
 590 // ---------------------------------------------------------------------
 591 /* This fixes the permissions */
 592 bool dsDirCorrect::SetPerm(dsFList &List,string Dir)
 593 {
 594    if (chmod(List.Entity->Name.c_str(),List.Entity->Permissions) != 0)
 595       return _error->Errno("chmod","Unable to change permissions for %s%s",
 596                            Dir.c_str(),List.Entity->Name.c_str());
 597    return true;
 598 }
 599                                                                         /*}}}*/
 600 // Dircorrect::SetOwner - Change ownership                              /*{{{*/
 601 // ---------------------------------------------------------------------
 602 /* This fixes the file ownership */
 603 bool dsDirCorrect::SetOwners(dsFList &List,string Dir)
 604 {
 605    return _error->Error("Ownership is not yet supported");
 606 }
 607                                                                         /*}}}*/
 608