apt-inst/deb/dpkgdb.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: dpkgdb.cc,v 1.7.2.1 2004/01/16 18:58:50 mdz Exp $
   4 /* ######################################################################
   5
   6    DPKGv1 Database Implemenation
   7
   8    This class provides parsers and other implementations for the DPKGv1
   9    database. It reads the diversion file, the list files and the status
  10    file to build both the list of currently installed files and the
  11    currently installed package list.
  12
  13    ##################################################################### */
  14                                                                         /*}}}*/
  15 // Include Files                                                        /*{{{*/
  16 #include<config.h>
  17
  18 #include <apt-pkg/dpkgdb.h>
  19 #include <apt-pkg/configuration.h>
  20 #include <apt-pkg/error.h>
  21 #include <apt-pkg/progress.h>
  22 #include <apt-pkg/tagfile.h>
  23 #include <apt-pkg/strutl.h>
  24 #include <apt-pkg/fileutl.h>
  25 #include <apt-pkg/filelist.h>
  26
  27 #include <stdio.h>
  28 #include <errno.h>
  29 #include <sys/stat.h>
  30 #include <sys/mman.h>
  31 #include <fcntl.h>
  32 #include <unistd.h>
  33 #include <ctype.h>
  34 #include <iostream>
  35 #include <apti18n.h>
  36                                                                         /*}}}*/
  37 using namespace std;
  38
  39 // EraseDir - Erase A Directory                                         /*{{{*/
  40 // ---------------------------------------------------------------------
  41 /* This is necessary to create a new empty sub directory. The caller should
  42    invoke mkdir after this with the proper permissions and check for
  43    error. Maybe stick this in fileutils */
  44 static bool EraseDir(const char *Dir)
  45 {
  46    // First we try a simple RM
  47    if (rmdir(Dir) == 0 ||
  48        errno == ENOENT)
  49       return true;
  50
  51    // A file? Easy enough..
  52    if (errno == ENOTDIR)
  53    {
  54       if (unlink(Dir) != 0)
  55          return _error->Errno("unlink",_("Failed to remove %s"),Dir);
  56       return true;
  57    }
  58
  59    // Should not happen
  60    if (errno != ENOTEMPTY)
  61       return _error->Errno("rmdir",_("Failed to remove %s"),Dir);
  62
  63    // Purge it using rm
  64    pid_t Pid = ExecFork();
  65
  66    // Spawn the subprocess
  67    if (Pid == 0)
  68    {
  69       execlp(_config->Find("Dir::Bin::rm","/bin/rm").c_str(),
  70              "rm","-rf","--",Dir,(char *)NULL);
  71       _exit(100);
  72    }
  73    return ExecWait(Pid,_config->Find("dir::bin::rm","/bin/rm").c_str());
  74 }
  75                                                                         /*}}}*/
  76 // DpkgDB::debDpkgDB - Constructor                                      /*{{{*/
  77 // ---------------------------------------------------------------------
  78 /* */
  79 debDpkgDB::debDpkgDB() : CacheMap(0), FileMap(0)
  80 {
  81    AdminDir = flNotFile(_config->Find("Dir::State::status"));
  82    DiverInode = 0;
  83    DiverTime = 0;
  84 }
  85                                                                         /*}}}*/
  86 // DpkgDB::~debDpkgDB - Destructor                                      /*{{{*/
  87 // ---------------------------------------------------------------------
  88 /* */
  89 debDpkgDB::~debDpkgDB()
  90 {
  91    delete Cache;
  92    Cache = 0;
  93    delete CacheMap;
  94    CacheMap = 0;
  95
  96    delete FList;
  97    FList = 0;
  98    delete FileMap;
  99    FileMap = 0;
 100 }
 101                                                                         /*}}}*/
 102 // DpkgDB::InitMetaTmp - Get the temp dir for meta information          /*{{{*/
 103 // ---------------------------------------------------------------------
 104 /* This creats+empties the meta temporary directory /var/lib/dpkg/tmp.ci
 105    Only one package at a time can be using the returned meta directory. */
 106 bool debDpkgDB::InitMetaTmp(string &Dir)
 107 {
 108    string Tmp = AdminDir + "tmp.ci/";
 109    if (EraseDir(Tmp.c_str()) == false)
 110       return _error->Error(_("Unable to create %s"),Tmp.c_str());
 111    if (mkdir(Tmp.c_str(),0755) != 0)
 112       return _error->Errno("mkdir",_("Unable to create %s"),Tmp.c_str());
 113
 114    // Verify it is on the same filesystem as the main info directory
 115    dev_t Dev;
 116    struct stat St;
 117    if (stat((AdminDir + "info").c_str(),&St) != 0)
 118       return _error->Errno("stat",_("Failed to stat %sinfo"),AdminDir.c_str());
 119    Dev = St.st_dev;
 120    if (stat(Tmp.c_str(),&St) != 0)
 121       return _error->Errno("stat",_("Failed to stat %s"),Tmp.c_str());
 122    if (Dev != St.st_dev)
 123       return _error->Error(_("The info and temp directories need to be on the same filesystem"));
 124
 125    // Done
 126    Dir = Tmp;
 127    return true;
 128 }
 129                                                                         /*}}}*/
 130 // DpkgDB::ReadyPkgCache - Prepare the cache with the current status    /*{{{*/
 131 // ---------------------------------------------------------------------
 132 /* This reads in the status file into an empty cache. This really needs
 133    to be somehow unified with the high level APT notion of the Database
 134    directory, but there is no clear way on how to do that yet. */
 135 bool debDpkgDB::ReadyPkgCache(OpProgress &Progress)
 136 {
 137    if (Cache != 0)
 138    {
 139       Progress.OverallProgress(1,1,1,_("Reading package lists"));
 140       return true;
 141    }
 142
 143    if (CacheMap != 0)
 144    {
 145       delete CacheMap;
 146       CacheMap = 0;
 147    }
 148
 149    if (pkgCacheGenerator::MakeOnlyStatusCache(&Progress,&CacheMap) == false)
 150       return false;
 151    Cache->DropProgress();
 152
 153    return true;
 154 }
 155                                                                         /*}}}*/
 156 // DpkgDB::ReadFList - Read the File Listings in                        /*{{{*/
 157 // ---------------------------------------------------------------------
 158 /* This reads the file listing in from the state directory. This is a
 159    performance critical routine, as it needs to parse about 50k lines of
 160    text spread over a hundred or more files. For an initial cold start
 161    most of the time is spent in reading file inodes and so on, not
 162    actually parsing. */
 163 bool debDpkgDB::ReadFList(OpProgress &Progress)
 164 {
 165    // Count the number of packages we need to read information for
 166    unsigned long Total = 0;
 167    pkgCache &Cache = this->Cache->GetCache();
 168    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
 169    {
 170       // Only not installed packages have no files.
 171       if (I->CurrentState == pkgCache::State::NotInstalled)
 172          continue;
 173       Total++;
 174    }
 175
 176    /* Switch into the admin dir, this prevents useless lookups for the
 177       path components */
 178    string Cwd = SafeGetCWD();
 179    if (chdir((AdminDir + "info/").c_str()) != 0)
 180       return _error->Errno("chdir",_("Failed to change to the admin dir %sinfo"),AdminDir.c_str());
 181
 182    // Allocate a buffer. Anything larger than this buffer will be mmaped
 183    unsigned long BufSize = 32*1024;
 184    char *Buffer = new char[BufSize];
 185
 186    // Begin Loading them
 187    unsigned long Count = 0;
 188    char Name[300];
 189    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
 190    {
 191       /* Only not installed packages have no files. ConfFile packages have
 192          file lists but we don't want to read them in */
 193       if (I->CurrentState == pkgCache::State::NotInstalled ||
 194           I->CurrentState == pkgCache::State::ConfigFiles)
 195          continue;
 196
 197       // Fetch a package handle to associate with the file
 198       pkgFLCache::PkgIterator FlPkg = FList->GetPkg(I.Name(),0,true);
 199       if (FlPkg.end() == true)
 200       {
 201          _error->Error(_("Internal error getting a package name"));
 202          break;
 203       }
 204
 205       Progress.OverallProgress(Count,Total,1,_("Reading file listing"));
 206
 207       // Open the list file
 208       snprintf(Name,sizeof(Name),"%s.list",I.Name());
 209       int Fd = open(Name,O_RDONLY);
 210
 211       /* Okay this is very strange and bad.. Best thing is to bail and
 212          instruct the user to look into it. */
 213       struct stat Stat;
 214       if (Fd == -1 || fstat(Fd,&Stat) != 0)
 215       {
 216          _error->Errno("open",_("Failed to open the list file '%sinfo/%s'. If you "
 217                        "cannot restore this file then make it empty "
 218                        "and immediately re-install the same version of the package!"),
 219                        AdminDir.c_str(),Name);
 220          break;
 221       }
 222
 223       // Set File to be a memory buffer containing the whole file
 224       char *File;
 225       if ((unsigned)Stat.st_size < BufSize)
 226       {
 227          if (read(Fd,Buffer,Stat.st_size) != Stat.st_size)
 228          {
 229             _error->Errno("read",_("Failed reading the list file %sinfo/%s"),
 230                           AdminDir.c_str(),Name);
 231             close(Fd);
 232             break;
 233          }
 234          File = Buffer;
 235       }
 236       else
 237       {
 238          // Use mmap
 239          File = (char *)mmap(0,Stat.st_size,PROT_READ,MAP_PRIVATE,Fd,0);
 240          if (File == (char *)(-1))
 241          {
 242             _error->Errno("mmap",_("Failed reading the list file %sinfo/%s"),
 243                           AdminDir.c_str(),Name);
 244             close(Fd);
 245             break;
 246          }
 247       }
 248
 249       // Parse it
 250       const char *Start = File;
 251       const char *End = File;
 252       const char *Finish = File + Stat.st_size;
 253       for (; End < Finish; End++)
 254       {
 255          // Not an end of line
 256          if (*End != '\n' && End + 1 < Finish)
 257             continue;
 258
 259          // Skip blank lines
 260          if (End - Start > 1)
 261          {
 262             pkgFLCache::NodeIterator Node = FList->GetNode(Start,End,
 263                                               FlPkg.Offset(),true,false);
 264             if (Node.end() == true)
 265             {
 266                _error->Error(_("Internal error getting a node"));
 267                break;
 268             }
 269          }
 270
 271          // Skip past the end of line
 272          for (; *End == '\n' && End < Finish; End++);
 273          Start = End;
 274       }
 275
 276       close(Fd);
 277       if ((unsigned)Stat.st_size >= BufSize)
 278          munmap((caddr_t)File,Stat.st_size);
 279
 280       // Failed
 281       if (End < Finish)
 282          break;
 283
 284       Count++;
 285    }
 286
 287    delete [] Buffer;
 288    if (chdir(Cwd.c_str()) != 0)
 289       return _error->Errno("chdir",_("Unable to change to %s"),Cwd.c_str());
 290    return !_error->PendingError();
 291 }
 292                                                                         /*}}}*/
 293 // DpkgDB::ReadDiversions - Load the diversions file                    /*{{{*/
 294 // ---------------------------------------------------------------------
 295 /* Read the diversion file in from disk. This is usually invoked by
 296    LoadChanges before performing an operation that uses the FLCache. */
 297 bool debDpkgDB::ReadDiversions()
 298 {
 299    struct stat Stat;
 300    if (stat((AdminDir + "diversions").c_str(),&Stat) != 0)
 301       return true;
 302
 303    if (_error->PendingError() == true)
 304       return false;
 305
 306    FILE *Fd = fopen((AdminDir + "diversions").c_str(),"r");
 307    if (Fd == 0)
 308       return _error->Errno("fopen",_("Failed to open the diversions file %sdiversions"),AdminDir.c_str());
 309
 310    FList->BeginDiverLoad();
 311    while (1)
 312    {
 313       char From[300];
 314       char To[300];
 315       char Package[100];
 316
 317       // Read the three lines in
 318       if (fgets(From,sizeof(From),Fd) == 0)
 319          break;
 320       if (fgets(To,sizeof(To),Fd) == 0 ||
 321           fgets(Package,sizeof(Package),Fd) == 0)
 322       {
 323          _error->Error(_("The diversion file is corrupted"));
 324          break;
 325       }
 326
 327       // Strip the \ns
 328       unsigned long Len = strlen(From);
 329       if (Len < 2 || From[Len-1] != '\n')
 330          _error->Error(_("Invalid line in the diversion file: %s"),From);
 331       else
 332          From[Len-1] = 0;
 333       Len = strlen(To);
 334       if (Len < 2 || To[Len-1] != '\n')
 335          _error->Error(_("Invalid line in the diversion file: %s"),To);
 336       else
 337          To[Len-1] = 0;
 338       Len = strlen(Package);
 339       if (Len < 2 || Package[Len-1] != '\n')
 340          _error->Error(_("Invalid line in the diversion file: %s"),Package);
 341       else
 342          Package[Len-1] = 0;
 343
 344       // Make sure the lines were parsed OK
 345       if (_error->PendingError() == true)
 346          break;
 347
 348       // Fetch a package
 349       if (strcmp(Package,":") == 0)
 350          Package[0] = 0;
 351       pkgFLCache::PkgIterator FlPkg = FList->GetPkg(Package,0,true);
 352       if (FlPkg.end() == true)
 353       {
 354          _error->Error(_("Internal error getting a package name"));
 355          break;
 356       }
 357
 358       // Install the diversion
 359       if (FList->AddDiversion(FlPkg,From,To) == false)
 360       {
 361          _error->Error(_("Internal error adding a diversion"));
 362          break;
 363       }
 364    }
 365    if (_error->PendingError() == false)
 366       FList->FinishDiverLoad();
 367
 368    DiverInode = Stat.st_ino;
 369    DiverTime = Stat.st_mtime;
 370
 371    fclose(Fd);
 372    return !_error->PendingError();
 373 }
 374                                                                         /*}}}*/
 375 // DpkgDB::ReadFileList - Read the file listing                         /*{{{*/
 376 // ---------------------------------------------------------------------
 377 /* Read in the file listing. The file listing is created from three
 378    sources, *.list, Conffile sections and the Diversion table. */
 379 bool debDpkgDB::ReadyFileList(OpProgress &Progress)
 380 {
 381    if (Cache == 0)
 382       return _error->Error(_("The pkg cache must be initialized first"));
 383    if (FList != 0)
 384    {
 385       Progress.OverallProgress(1,1,1,_("Reading file listing"));
 386       return true;
 387    }
 388
 389    // Create the cache and read in the file listing
 390    FileMap = new DynamicMMap(MMap::Public);
 391    FList = new pkgFLCache(*FileMap);
 392    if (_error->PendingError() == true ||
 393        ReadFList(Progress) == false ||
 394        ReadConfFiles() == false ||
 395        ReadDiversions() == false)
 396    {
 397       delete FList;
 398       delete FileMap;
 399       FileMap = 0;
 400       FList = 0;
 401       return false;
 402    }
 403
 404    cout << "Node: " << FList->HeaderP->NodeCount << ',' << FList->HeaderP->UniqNodes << endl;
 405    cout << "Dir: " << FList->HeaderP->DirCount << endl;
 406    cout << "Package: " << FList->HeaderP->PackageCount << endl;
 407    cout << "HashSize: " << FList->HeaderP->HashSize << endl;
 408    cout << "Size: " << FileMap->Size() << endl;
 409    cout << endl;
 410
 411    return true;
 412 }
 413                                                                         /*}}}*/
 414 // DpkgDB::ReadConfFiles - Read the conf file sections from the s-file  /*{{{*/
 415 // ---------------------------------------------------------------------
 416 /* Reading the conf files is done by reparsing the status file. This is
 417    actually rather fast so it is no big deal. */
 418 bool debDpkgDB::ReadConfFiles()
 419 {
 420    FileFd File(_config->FindFile("Dir::State::status"),FileFd::ReadOnly);
 421    pkgTagFile Tags(&File);
 422    if (_error->PendingError() == true)
 423       return false;
 424
 425    pkgTagSection Section;
 426    while (1)
 427    {
 428       // Skip to the next section
 429       unsigned long Offset = Tags.Offset();
 430       if (Tags.Step(Section) == false)
 431          break;
 432
 433       // Parse the line
 434       const char *Start;
 435       const char *Stop;
 436       if (Section.Find("Conffiles",Start,Stop) == false)
 437          continue;
 438
 439       const char *PkgStart;
 440       const char *PkgEnd;
 441       if (Section.Find("Package",PkgStart,PkgEnd) == false)
 442          return _error->Error(_("Failed to find a Package: header, offset %lu"),Offset);
 443
 444       // Snag a package record for it
 445       pkgFLCache::PkgIterator FlPkg = FList->GetPkg(PkgStart,PkgEnd,true);
 446       if (FlPkg.end() == true)
 447          return _error->Error(_("Internal error getting a package name"));
 448
 449       // Parse the conf file lines
 450       while (1)
 451       {
 452          for (; isspace(*Start) != 0 && Start < Stop; Start++);
 453          if (Start == Stop)
 454             break;
 455
 456          // Split it into words
 457          const char *End = Start;
 458          for (; isspace(*End) == 0 && End < Stop; End++);
 459          const char *StartMd5 = End;
 460          for (; isspace(*StartMd5) != 0 && StartMd5 < Stop; StartMd5++);
 461          const char *EndMd5 = StartMd5;
 462          for (; isspace(*EndMd5) == 0 && EndMd5 < Stop; EndMd5++);
 463          if (StartMd5 == EndMd5 || Start == End)
 464             return _error->Error(_("Bad ConfFile section in the status file. Offset %lu"),Offset);
 465
 466          // Insert a new entry
 467          unsigned char MD5[16];
 468          if (Hex2Num(string(StartMd5,EndMd5-StartMd5),MD5,16) == false)
 469             return _error->Error(_("Error parsing MD5. Offset %lu"),Offset);
 470
 471          if (FList->AddConfFile(Start,End,FlPkg,MD5) == false)
 472             return false;
 473          Start = EndMd5;
 474       }
 475    }
 476
 477    return true;
 478 }
 479                                                                         /*}}}*/
 480 // DpkgDB::LoadChanges - Read in any changed state files                /*{{{*/
 481 // ---------------------------------------------------------------------
 482 /* The only file in the dpkg system that can change while packages are
 483    unpacking is the diversions file. */
 484 bool debDpkgDB::LoadChanges()
 485 {
 486    struct stat Stat;
 487    if (stat((AdminDir + "diversions").c_str(),&Stat) != 0)
 488       return true;
 489    if (DiverInode == Stat.st_ino && DiverTime == Stat.st_mtime)
 490       return true;
 491    return ReadDiversions();
 492 }
 493                                                                         /*}}}*/