tools/dsync-0.0/libdsync/genfilelist.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: genfilelist.cc,v 1.10 1999/12/26 06:59:01 jgg Exp $
   4 /* ######################################################################
   5
   6    Generate File List
   7
   8    File list generation can be done with modification to the generation
   9    order, ordering can be done by depth, breadth or by tree with and
  10    a fitler can be applied to delay a directory till the end of processing.
  11
  12    The emitter simply generates the necessary structure and writes it to
  13    the IO. The client can hook some of the functions to provide progress
  14    reporting and md5 caching if so desired.
  15
  16    ##################################################################### */
  17                                                                         /*}}}*/
  18 // Include files                                                        /*{{{*/
  19 #ifdef __GNUG__
  20 #pragma implementation "dsync/genfilelist.h"
  21 #endif
  22
  23 #include <dsync/genfilelist.h>
  24 #include <dsync/error.h>
  25 #include <dsync/fileutl.h>
  26 #include <dsync/md5.h>
  27 #include <dsync/fileutl.h>
  28 #include <dsync/rsync-algo.h>
  29
  30 #include <sys/stat.h>
  31 #include <unistd.h>
  32 #include <dirent.h>
  33 #include <stdio.h>
  34                                                                         /*}}}*/
  35
  36 // GenFileList::dsGenFileList - Constructor                             /*{{{*/
  37 // ---------------------------------------------------------------------
  38 /* */
  39 dsGenFileList::dsGenFileList() : IO(0), Type(Tree)
  40 {
  41 }
  42                                                                         /*}}}*/
  43 // GenFileList::~dsGenFileList - Destructor                             /*{{{*/
  44 // ---------------------------------------------------------------------
  45 /* */
  46 dsGenFileList::~dsGenFileList()
  47 {
  48 }
  49                                                                         /*}}}*/
  50 // GenFileList::Go - Generate the list                                  /*{{{*/
  51 // ---------------------------------------------------------------------
  52 /* This invokes the proper recursive directory scanner to build the file
  53    names. Depth and Breath use a queue */
  54 bool dsGenFileList::Go(string Base,dsFList::IO &IO)
  55 {
  56    // Setup the queues and store the current directory
  57    string StartDir = SafeGetCWD();
  58    Queue.erase(Queue.begin(),Queue.end());
  59    DelayQueue.erase(Queue.begin(),Queue.end());
  60
  61    struct stat St;
  62    if (stat(Base.c_str(),&St) != 0)
  63       return _error->Errno("stat","Could not stat the base directory");
  64
  65    // Begin
  66    this->IO = &IO;
  67    IO.Header.Write(IO);
  68
  69    switch (Type)
  70    {
  71       case Depth:
  72       {
  73          // Change to the base directory
  74          if (chdir(Base.c_str()) != 0)
  75             return _error->Errno("chdir","Could not change to %s",Base.c_str());
  76          Base = SafeGetCWD();
  77
  78          char Cwd[1024];
  79          Cwd[0] = 0;
  80          if (DirDepthFirst(Cwd) == false)
  81          {
  82             chdir(StartDir.c_str());
  83             return false;
  84          }
  85
  86          // Now deal with the delay list
  87          while (DelayQueue.empty() == false)
  88          {
  89             // Get the first delayed directory
  90             string Dir = DelayQueue.front();
  91             DelayQueue.pop_front();
  92
  93             // Change to it and emit it.
  94             strcpy(Cwd,Dir.c_str());
  95             chdir(Base.c_str());
  96             chdir(Cwd);
  97             if (DirDepthFirst(Cwd) == false)
  98             {
  99                chdir(StartDir.c_str());
 100                return false;
 101             }
 102          }
 103
 104          break;
 105       }
 106
 107       case Tree:
 108       case Breadth:
 109       {
 110          // Change to the base directory
 111          if (chdir(Base.c_str()) != 0)
 112             return _error->Errno("chdir","Could not change to %s",Base.c_str());
 113          Base = SafeGetCWD();
 114
 115          Queue.push_back("");
 116          while (Queue.empty() == false || DelayQueue.empty() == false)
 117          {
 118             if (DirTree() == false)
 119             {
 120                chdir(StartDir.c_str());
 121                return false;
 122             }
 123
 124             chdir(Base.c_str());
 125          }
 126          break;
 127       }
 128
 129       default:
 130       return _error->Error("Internal Error");
 131    };
 132
 133    chdir(StartDir.c_str());
 134
 135    dsFList::Trailer Trail;
 136    return Trail.Write(IO);
 137 }
 138                                                                         /*}}}*/
 139 // GenFileList::DirDepthFirst - Depth first directory ordering          /*{{{*/
 140 // ---------------------------------------------------------------------
 141 /* */
 142 bool dsGenFileList::DirDepthFirst(char *CurDir)
 143 {
 144    // Scan the directory, first pass is to descend into the sub directories
 145    DIR *DirSt = opendir(".");
 146    if (DirSt == 0)
 147       return _error->Errno("opendir","Unable to open direcotry %s",CurDir);
 148    struct dirent *Ent;
 149    bool EmittedThis = false;
 150    struct stat St;
 151    while ((Ent = readdir(DirSt)) != 0)
 152    {
 153       // Skip . and ..
 154       if (strcmp(Ent->d_name,".") == 0 ||
 155           strcmp(Ent->d_name,"..") == 0)
 156          continue;
 157
 158       if (lstat(Ent->d_name,&St) != 0)
 159       {
 160          closedir(DirSt);
 161          return _error->Errno("stat","Could not stat %s%s",CurDir,Ent->d_name);
 162       }
 163
 164       // it is a directory
 165       if (S_ISDIR(St.st_mode) != 0)
 166       {
 167          char S[1024];
 168          snprintf(S,sizeof(S),"%s/",Ent->d_name);
 169
 170          // Check the Filter
 171          if (Filter.Test(CurDir,S) == false)
 172             continue;
 173
 174          // Emit a directory marker record for this directory
 175          if (EmittedThis == false)
 176          {
 177             EmittedThis = true;
 178
 179             if (lstat(".",&St) != 0)
 180             {
 181                closedir(DirSt);
 182                return _error->Errno("stat","Could not stat %s",CurDir);
 183             }
 184
 185             if (DirectoryMarker(CurDir,St) == false)
 186             {
 187                closedir(DirSt);
 188                return false;
 189             }
 190          }
 191
 192          // Check the delay filter
 193          if (PreferFilter.Test(CurDir,S) == false)
 194          {
 195             snprintf(S,sizeof(S),"%s%s/",CurDir,Ent->d_name);
 196             DelayQueue.push_back(S);
 197             continue;
 198          }
 199
 200          // Append the new directory to CurDir and decend
 201          char *End = CurDir + strlen(CurDir);
 202          strcat(End,S);
 203          if (chdir(S) != 0)
 204          {
 205             closedir(DirSt);
 206             return _error->Errno("chdir","Could not chdir to %s%s",CurDir,S);
 207          }
 208
 209          // Recurse
 210          if (DirDepthFirst(CurDir) == false)
 211          {
 212             closedir(DirSt);
 213             return false;
 214          }
 215
 216          if (chdir("..") != 0)
 217          {
 218             closedir(DirSt);
 219             return _error->Errno("chdir","Could not chdir to %s%s",CurDir,S);
 220          }
 221
 222          // Chop off the directory we added to the current dir
 223          *End = 0;
 224       }
 225    }
 226    rewinddir(DirSt);
 227
 228    // Begin emitting this directory
 229    if (lstat(".",&St) != 0)
 230    {
 231       closedir(DirSt);
 232       return _error->Errno("stat","Could not stat %s",CurDir);
 233    }
 234
 235    if (EnterDir(CurDir,St) == false)
 236    {
 237       closedir(DirSt);
 238       return false;
 239    }
 240
 241    while ((Ent = readdir(DirSt)) != 0)
 242    {
 243       // Skip . and ..
 244       if (strcmp(Ent->d_name,".") == 0 ||
 245           strcmp(Ent->d_name,"..") == 0)
 246          continue;
 247
 248       struct stat St;
 249       if (lstat(Ent->d_name,&St) != 0)
 250       {
 251          closedir(DirSt);
 252          return _error->Errno("stat","Could not stat %s%s",CurDir,Ent->d_name);
 253       }
 254
 255       // it is a directory
 256       if (S_ISDIR(St.st_mode) != 0)
 257       {
 258          char S[1024];
 259          snprintf(S,sizeof(S),"%s/",Ent->d_name);
 260
 261          // Check the Filter
 262          if (Filter.Test(CurDir,S) == false)
 263             continue;
 264       }
 265       else
 266       {
 267          // Check the Filter
 268          if (Filter.Test(CurDir,Ent->d_name) == false)
 269             continue;
 270       }
 271
 272       if (DoFile(CurDir,Ent->d_name,St) == false)
 273       {
 274          closedir(DirSt);
 275          return false;
 276       }
 277    }
 278    closedir(DirSt);
 279
 280    if (LeaveDir(CurDir) == false)
 281       return false;
 282
 283    return true;
 284 }
 285                                                                         /*}}}*/
 286 // GenFileList::DirTree - Breadth/Tree directory ordering               /*{{{*/
 287 // ---------------------------------------------------------------------
 288 /* Breadth ordering does all of the dirs at each depth before proceeding
 289    to the next depth. We just treat the list as a queue to get this
 290    effect. Tree ordering does things in a more normal recursive fashion,
 291    we treat the queue as a stack to get that effect. */
 292 bool dsGenFileList::DirTree()
 293 {
 294    string Dir;
 295    if (Queue.empty() == false)
 296    {
 297       Dir = Queue.front();
 298       Queue.pop_front();
 299    }
 300    else
 301    {
 302       Dir = DelayQueue.front();
 303       DelayQueue.pop_front();
 304    }
 305
 306    struct stat St;
 307    if (Dir.empty() == false && chdir(Dir.c_str()) != 0 || stat(".",&St) != 0)
 308       return _error->Errno("chdir","Could not change to %s",Dir.c_str());
 309
 310    if (EnterDir(Dir.c_str(),St) == false)
 311       return false;
 312
 313    // Scan the directory
 314    DIR *DirSt = opendir(".");
 315    if (DirSt == 0)
 316       return _error->Errno("opendir","Unable to open direcotry %s",Dir.c_str());
 317    struct dirent *Ent;
 318    while ((Ent = readdir(DirSt)) != 0)
 319    {
 320       // Skip . and ..
 321       if (strcmp(Ent->d_name,".") == 0 ||
 322           strcmp(Ent->d_name,"..") == 0)
 323          continue;
 324
 325       if (lstat(Ent->d_name,&St) != 0)
 326       {
 327          closedir(DirSt);
 328          return _error->Errno("stat","Could not stat %s%s",Dir.c_str(),Ent->d_name);
 329       }
 330
 331       // It is a directory
 332       if (S_ISDIR(St.st_mode) != 0)
 333       {
 334          char S[1024];
 335          snprintf(S,sizeof(S),"%s/",Ent->d_name);
 336
 337          // Check the Filter
 338          if (Filter.Test(Dir.c_str(),S) == false)
 339             continue;
 340
 341          // Check the delay filter
 342          if (PreferFilter.Test(Dir.c_str(),S) == false)
 343          {
 344             snprintf(S,sizeof(S),"%s%s/",Dir.c_str(),Ent->d_name);
 345             if (Type == Tree)
 346                DelayQueue.push_front(S);
 347             else
 348                DelayQueue.push_back(S);
 349             continue;
 350          }
 351
 352          snprintf(S,sizeof(S),"%s%s/",Dir.c_str(),Ent->d_name);
 353
 354          if (Type == Tree)
 355             Queue.push_front(S);
 356          else
 357             Queue.push_back(S);
 358       }
 359       else
 360       {
 361          // Check the Filter
 362          if (Filter.Test(Dir.c_str(),Ent->d_name) == false)
 363             continue;
 364       }
 365
 366       if (DoFile(Dir.c_str(),Ent->d_name,St) == false)
 367       {
 368          closedir(DirSt);
 369          return false;
 370       }
 371    }
 372    closedir(DirSt);
 373
 374    if (LeaveDir(Dir.c_str()) == false)
 375       return false;
 376
 377    return true;
 378 }
 379                                                                         /*}}}*/
 380
 381 // GenFileList::EnterDir - Called when a directory is entered           /*{{{*/
 382 // ---------------------------------------------------------------------
 383 /* This is called to start a directory block the current working dir
 384    should be set to the directory entered. This emits the directory start
 385    record */
 386 bool dsGenFileList::EnterDir(const char *Dir,struct stat const &St)
 387 {
 388    if (Visit(Dir,0,St) != 0)
 389       return false;
 390
 391    dsFList::Directory D;
 392    D.Tag = dsFList::tDirStart;
 393    D.ModTime = St.st_mtime - IO->Header.Epoch;
 394    D.Permissions = St.st_mode & ~S_IFMT;
 395    D.Name = Dir;
 396    return EmitOwner(St,D.User,D.Group,D.Tag,dsFList::Directory::FlOwner) &&
 397       D.Write(*IO);
 398 }
 399                                                                         /*}}}*/
 400 // GenFileList::LeaveDir - Called when a directory is left              /*{{{*/
 401 // ---------------------------------------------------------------------
 402 /* Don't do anything for now */
 403 bool dsGenFileList::LeaveDir(const char *Dir)
 404 {
 405    return true;
 406 }
 407                                                                         /*}}}*/
 408 // GenFileList::DirectoryMarker - Called when a dir is skipped          /*{{{*/
 409 // ---------------------------------------------------------------------
 410 /* This is used by the depth first ordering, when a dir is temporarily
 411    skipped over this function is called to emit a marker */
 412 bool dsGenFileList::DirectoryMarker(const char *Dir,
 413                                     struct stat const &St)
 414 {
 415    dsFList::Directory D;
 416    D.Tag = dsFList::tDirMarker;
 417    D.ModTime = St.st_mtime - IO->Header.Epoch;
 418    D.Permissions = St.st_mode & ~S_IFMT;
 419    D.Name = Dir;
 420    return EmitOwner(St,D.User,D.Group,D.Tag,dsFList::Directory::FlOwner) &&
 421       D.Write(*IO);
 422 }
 423                                                                         /*}}}*/
 424 // GenFileList::DoFile - This does all other items in a directory       /*{{{*/
 425 // ---------------------------------------------------------------------
 426 /* The different file types are emitted as perscribed by the file list
 427    document */
 428 bool dsGenFileList::DoFile(const char *Dir,const char *File,
 429                            struct stat const &St)
 430 {
 431    int Res = Visit(Dir,File,St);
 432    if (Res < 0)
 433       return false;
 434    if (Res > 0)
 435       return true;
 436
 437    // Regular file
 438    if (S_ISREG(St.st_mode) != 0)
 439    {
 440       dsFList::NormalFile F;
 441
 442       F.Tag = dsFList::tNormalFile;
 443       F.ModTime = St.st_mtime - IO->Header.Epoch;
 444       F.Permissions = St.st_mode & ~S_IFMT;
 445       F.Name = File;
 446       F.Size = St.st_size;
 447
 448       if (EmitOwner(St,F.User,F.Group,F.Tag,dsFList::NormalFile::FlOwner) == false)
 449          return false;
 450
 451       // See if we need to emit rsync checksums
 452       if (NeedsRSync(Dir,File,F) == true)
 453       {
 454          dsFList::RSyncChecksum Ck;
 455          if (EmitRSync(Dir,File,St,F,Ck) == false)
 456             return false;
 457
 458          // Write out the file record, the checksums and the end marker
 459          return F.Write(*IO) && Ck.Write(*IO);
 460       }
 461       else
 462       {
 463          if (EmitMD5(Dir,File,St,F.MD5,F.Tag,
 464                      dsFList::NormalFile::FlMD5) == false)
 465             return false;
 466
 467          return F.Write(*IO);
 468       }
 469    }
 470
 471    // Directory
 472    if (S_ISDIR(St.st_mode) != 0)
 473    {
 474       dsFList::Directory D;
 475       D.Tag = dsFList::tDirectory;
 476       D.ModTime = St.st_mtime - IO->Header.Epoch;
 477       D.Permissions = St.st_mode & ~S_IFMT;
 478       D.Name = File;
 479       return EmitOwner(St,D.User,D.Group,D.Tag,dsFList::Directory::FlOwner) &&
 480          D.Write(*IO);
 481    }
 482
 483    // Link
 484    if (S_ISLNK(St.st_mode) != 0)
 485    {
 486       dsFList::Symlink L;
 487       L.Tag = dsFList::tSymlink;
 488       L.ModTime = St.st_mtime - IO->Header.Epoch;
 489       L.Name = File;
 490
 491       char Buf[1024];
 492       int Res = readlink(File,Buf,sizeof(Buf));
 493       if (Res <= 0)
 494          return _error->Errno("readlink","Unable to read symbolic link");
 495       Buf[Res] = 0;
 496       L.To = Buf;
 497
 498       return EmitOwner(St,L.User,L.Group,L.Tag,dsFList::Symlink::FlOwner) &&
 499          L.Write(*IO);
 500    }
 501
 502    // Block special file
 503    if (S_ISCHR(St.st_mode) != 0 || S_ISBLK(St.st_mode) != 0 ||
 504        S_ISFIFO(St.st_mode) != 0)
 505    {
 506       dsFList::DeviceSpecial D;
 507       D.Tag = dsFList::tDeviceSpecial;
 508       D.ModTime = St.st_mtime - IO->Header.Epoch;
 509       D.Permissions = St.st_mode & ~S_IFMT;
 510       D.Dev = St.st_dev;
 511       D.Name = File;
 512
 513       return EmitOwner(St,D.User,D.Group,D.Tag,dsFList::DeviceSpecial::FlOwner) &&
 514          D.Write(*IO);
 515    }
 516
 517    return _error->Error("File %s%s is not a known type",Dir,File);
 518 }
 519                                                                         /*}}}*/
 520 // GenFileList::EmitOwner - Set the entitiy ownership                   /*{{{*/
 521 // ---------------------------------------------------------------------
 522 /* This emits the necessary UID/GID mapping records and sets the feilds
 523    in */
 524 bool dsGenFileList::EmitOwner(struct stat const &St,unsigned long &UID,
 525                               unsigned long &GID,unsigned int Tag,
 526                               unsigned int Flag)
 527 {
 528    if ((IO->Header.Flags[Tag] & Flag) != Flag)
 529       return true;
 530
 531    return _error->Error("UID/GID storage is not supported yet");
 532 }
 533                                                                         /*}}}*/
 534 // GenFileList::EmitMd5 - Generate the md5 hash for the file            /*{{{*/
 535 // ---------------------------------------------------------------------
 536 /* This uses the MD5 class to generate the md5 hash for the entry. */
 537 bool dsGenFileList::EmitMD5(const char *Dir,const char *File,
 538                             struct stat const &St,unsigned char MD5[16],
 539                             unsigned int Tag,unsigned int Flag)
 540 {
 541    if ((IO->Header.Flags[Tag] & Flag) != Flag)
 542       return true;
 543
 544    // Open the file
 545    MD5Summation Sum;
 546    FileFd Fd(File,FileFd::ReadOnly);
 547    if (_error->PendingError() == true)
 548       return _error->Error("MD5 generation failed for %s%s",Dir,File);
 549
 550    if (Sum.AddFD(Fd.Fd(),Fd.Size()) == false)
 551       return _error->Error("MD5 generation failed for %s%s",Dir,File);
 552
 553    Sum.Result().Value(MD5);
 554
 555    return true;
 556 }
 557                                                                         /*}}}*/
 558 // GenFileList::EmitRSync - Emit a RSync checksum record                /*{{{*/
 559 // ---------------------------------------------------------------------
 560 /* This just generates the checksum into the memory structure. */
 561 bool dsGenFileList::EmitRSync(const char *Dir,const char *File,
 562                               struct stat const &St,dsFList::NormalFile &F,
 563                               dsFList::RSyncChecksum &Ck)
 564 {
 565    FileFd Fd(File,FileFd::ReadOnly);
 566    if (_error->PendingError() == true)
 567       return _error->Error("RSync Checksum generation failed for %s%s",Dir,File);
 568
 569    if (GenerateRSync(Fd,Ck,F.MD5) == false)
 570       return _error->Error("RSync Checksum generation failed for %s%s",Dir,File);
 571
 572    return true;
 573 }
 574                                                                         /*}}}*/