apt-pkg/cdrom.cc

   1 /*
   2  */
   3 #include<config.h>
   4
   5 #include<apt-pkg/init.h>
   6 #include<apt-pkg/error.h>
   7 #include<apt-pkg/cdromutl.h>
   8 #include<apt-pkg/strutl.h>
   9 #include<apt-pkg/cdrom.h>
  10 #include<apt-pkg/aptconfiguration.h>
  11 #include<apt-pkg/configuration.h>
  12 #include<apt-pkg/fileutl.h>
  13
  14 #include<sstream>
  15 #include<fstream>
  16 #include <sys/stat.h>
  17 #include <fcntl.h>
  18 #include <dirent.h>
  19 #include <unistd.h>
  20 #include <stdio.h>
  21 #include <algorithm>
  22 #include <dlfcn.h>
  23
  24 #include "indexcopy.h"
  25
  26 #include<apti18n.h>
  27
  28 using namespace std;
  29
  30 // FindPackages - Find the package files on the CDROM                   /*{{{*/
  31 // ---------------------------------------------------------------------
  32 /* We look over the cdrom for package files. This is a recursive
  33    search that short circuits when it his a package file in the dir.
  34    This speeds it up greatly as the majority of the size is in the
  35    binary-* sub dirs. */
  36 bool pkgCdrom::FindPackages(string CD,
  37                             vector<string> &List,
  38                             vector<string> &SList,
  39                             vector<string> &SigList,
  40                             vector<string> &TransList,
  41                             string &InfoDir, pkgCdromStatus *log,
  42                             unsigned int Depth)
  43 {
  44    static ino_t Inodes[9];
  45    DIR *D;
  46
  47    // if we have a look we "pulse" now
  48    if(log)
  49       log->Update();
  50
  51    if (Depth >= 7)
  52       return true;
  53
  54    if (CD[CD.length()-1] != '/')
  55       CD += '/';
  56
  57    if (chdir(CD.c_str()) != 0)
  58       return _error->Errno("chdir","Unable to change to %s",CD.c_str());
  59
  60    // Look for a .disk subdirectory
  61    if (DirectoryExists(".disk") == true)
  62    {
  63       if (InfoDir.empty() == true)
  64          InfoDir = CD + ".disk/";
  65    }
  66
  67    // Don't look into directories that have been marked to ingore.
  68    if (RealFileExists(".aptignr") == true)
  69       return true;
  70
  71    /* Check _first_ for a signature file as apt-cdrom assumes that all files
  72       under a Packages/Source file are in control of that file and stops
  73       the scanning
  74    */
  75    if (RealFileExists("Release.gpg") == true || RealFileExists("InRelease") == true)
  76    {
  77       SigList.push_back(CD);
  78    }
  79
  80    /* Aha! We found some package files. We assume that everything under
  81       this dir is controlled by those package files so we don't look down
  82       anymore */
  83    std::vector<APT::Configuration::Compressor> const compressor = APT::Configuration::getCompressors();
  84    for (std::vector<APT::Configuration::Compressor>::const_iterator c = compressor.begin();
  85         c != compressor.end(); ++c)
  86    {
  87       if (RealFileExists(std::string("Packages").append(c->Extension).c_str()) == false)
  88          continue;
  89
  90       if (_config->FindB("Debug::aptcdrom",false) == true)
  91          std::clog << "Found Packages in " << CD << std::endl;
  92       List.push_back(CD);
  93
  94       // Continue down if thorough is given
  95       if (_config->FindB("APT::CDROM::Thorough",false) == false)
  96          return true;
  97       break;
  98    }
  99    for (std::vector<APT::Configuration::Compressor>::const_iterator c = compressor.begin();
 100         c != compressor.end(); ++c)
 101    {
 102       if (RealFileExists(std::string("Sources").append(c->Extension).c_str()) == false)
 103          continue;
 104
 105       if (_config->FindB("Debug::aptcdrom",false) == true)
 106          std::clog << "Found Sources in " << CD << std::endl;
 107       SList.push_back(CD);
 108
 109       // Continue down if thorough is given
 110       if (_config->FindB("APT::CDROM::Thorough",false) == false)
 111          return true;
 112       break;
 113    }
 114
 115    // see if we find translation indices
 116    if (DirectoryExists("i18n") == true)
 117    {
 118       D = opendir("i18n");
 119       for (struct dirent *Dir = readdir(D); Dir != 0; Dir = readdir(D))
 120       {
 121          if(strncmp(Dir->d_name, "Translation-", strlen("Translation-")) != 0)
 122             continue;
 123          string file = Dir->d_name;
 124          for (std::vector<APT::Configuration::Compressor>::const_iterator c = compressor.begin();
 125               c != compressor.end(); ++c)
 126          {
 127             string fileext = flExtension(file);
 128             if (file == fileext)
 129                fileext.clear();
 130             else if (fileext.empty() == false)
 131                fileext = "." + fileext;
 132
 133             if (c->Extension == fileext)
 134             {
 135                if (_config->FindB("Debug::aptcdrom",false) == true)
 136                   std::clog << "Found translation " << Dir->d_name << " in " << CD << "i18n/" << std::endl;
 137                file.erase(file.size() - fileext.size());
 138                TransList.push_back(CD + "i18n/" + file);
 139                break;
 140             }
 141          }
 142       }
 143       closedir(D);
 144    }
 145
 146    D = opendir(".");
 147    if (D == 0)
 148       return _error->Errno("opendir","Unable to read %s",CD.c_str());
 149
 150    // Run over the directory
 151    for (struct dirent *Dir = readdir(D); Dir != 0; Dir = readdir(D))
 152    {
 153       // Skip some files..
 154       if (strcmp(Dir->d_name,".") == 0 ||
 155           strcmp(Dir->d_name,"..") == 0 ||
 156           //strcmp(Dir->d_name,"source") == 0 ||
 157           strcmp(Dir->d_name,".disk") == 0 ||
 158           strcmp(Dir->d_name,"experimental") == 0 ||
 159           strcmp(Dir->d_name,"binary-all") == 0 ||
 160           strcmp(Dir->d_name,"debian-installer") == 0)
 161          continue;
 162
 163       // See if the name is a sub directory
 164       struct stat Buf;
 165       if (stat(Dir->d_name,&Buf) != 0)
 166          continue;
 167
 168       if (S_ISDIR(Buf.st_mode) == 0)
 169          continue;
 170
 171       unsigned int I;
 172       for (I = 0; I != Depth; I++)
 173          if (Inodes[I] == Buf.st_ino)
 174             break;
 175       if (I != Depth)
 176          continue;
 177
 178       // Store the inodes weve seen
 179       Inodes[Depth] = Buf.st_ino;
 180
 181       // Descend
 182       if (FindPackages(CD + Dir->d_name,List,SList,SigList,TransList,InfoDir,log,Depth+1) == false)
 183          break;
 184
 185       if (chdir(CD.c_str()) != 0)
 186       {
 187          _error->Errno("chdir","Unable to change to %s", CD.c_str());
 188          closedir(D);
 189          return false;
 190       }
 191    };
 192
 193    closedir(D);
 194
 195    return !_error->PendingError();
 196 }
 197                                                                         /*}}}*/
 198 // Score - We compute a 'score' for a path                              /*{{{*/
 199 // ---------------------------------------------------------------------
 200 /* Paths are scored based on how close they come to what I consider
 201    normal. That is ones that have 'dist' 'stable' 'testing' will score
 202    higher than ones without. */
 203 int pkgCdrom::Score(string Path)
 204 {
 205    int Res = 0;
 206    if (Path.find("stable/") != string::npos)
 207       Res += 29;
 208    if (Path.find("/binary-") != string::npos)
 209       Res += 20;
 210    if (Path.find("testing/") != string::npos)
 211       Res += 28;
 212    if (Path.find("unstable/") != string::npos)
 213       Res += 27;
 214    if (Path.find("/dists/") != string::npos)
 215       Res += 40;
 216    if (Path.find("/main/") != string::npos)
 217       Res += 20;
 218    if (Path.find("/contrib/") != string::npos)
 219       Res += 20;
 220    if (Path.find("/non-free/") != string::npos)
 221       Res += 20;
 222    if (Path.find("/non-US/") != string::npos)
 223       Res += 20;
 224    if (Path.find("/source/") != string::npos)
 225       Res += 10;
 226    if (Path.find("/debian/") != string::npos)
 227       Res -= 10;
 228
 229    // check for symlinks in the patch leading to the actual file
 230    // a symlink gets a big penalty
 231    struct stat Buf;
 232    string statPath = flNotFile(Path);
 233    string cdromPath = _config->FindDir("Acquire::cdrom::mount");
 234    while(statPath != cdromPath && statPath != "./") {
 235       statPath.resize(statPath.size()-1);  // remove the trailing '/'
 236       if (lstat(statPath.c_str(),&Buf) == 0) {
 237         if(S_ISLNK(Buf.st_mode)) {
 238            Res -= 60;
 239            break;
 240         }
 241       }
 242       statPath = flNotFile(statPath); // descent
 243    }
 244
 245    return Res;
 246 }
 247                                                                         /*}}}*/
 248 // DropBinaryArch - Dump dirs with a string like /binary-<foo>/         /*{{{*/
 249 // ---------------------------------------------------------------------
 250 /* Here we drop everything that is not this machines arch */
 251 bool pkgCdrom::DropBinaryArch(vector<string> &List)
 252 {
 253
 254    for (unsigned int I = 0; I < List.size(); I++)
 255    {
 256       const char *Str = List[I].c_str();
 257       const char *Start, *End;
 258       if ((Start = strstr(Str,"/binary-")) == 0)
 259          continue;
 260
 261       // Between Start and End is the architecture
 262       Start += 8;
 263       if ((End = strstr(Start,"/")) != 0 && Start != End &&
 264           APT::Configuration::checkArchitecture(string(Start, End)) == true)
 265          continue; // okay, architecture is accepted
 266
 267       // not accepted -> Erase it
 268       List.erase(List.begin() + I);
 269       --I; // the next entry is at the same index after the erase
 270    }
 271
 272    return true;
 273 }
 274                                                                         /*}}}*/
 275 // DropTranslation - Dump unwanted Translation-<lang> files             /*{{{*/
 276 // ---------------------------------------------------------------------
 277 /* Here we drop everything that is not configured in Acquire::Languages */
 278 bool pkgCdrom::DropTranslation(vector<string> &List)
 279 {
 280    for (unsigned int I = 0; I < List.size(); I++)
 281    {
 282       const char *Start;
 283       if ((Start = strstr(List[I].c_str(), "/Translation-")) == NULL)
 284          continue;
 285       Start += strlen("/Translation-");
 286
 287       if (APT::Configuration::checkLanguage(Start, true) == true)
 288          continue;
 289
 290       // not accepted -> Erase it
 291       List.erase(List.begin() + I);
 292       --I; // the next entry is at the same index after the erase
 293    }
 294
 295    return true;
 296 }
 297                                                                         /*}}}*/
 298 // DropRepeats - Drop repeated files resulting from symlinks            /*{{{*/
 299 // ---------------------------------------------------------------------
 300 /* Here we go and stat every file that we found and strip dup inodes. */
 301 bool pkgCdrom::DropRepeats(vector<string> &List,const char *Name)
 302 {
 303    bool couldFindAllFiles = true;
 304    // Get a list of all the inodes
 305    ino_t *Inodes = new ino_t[List.size()];
 306    for (unsigned int I = 0; I != List.size(); ++I)
 307    {
 308       struct stat Buf;
 309       bool found = false;
 310
 311       std::vector<APT::Configuration::Compressor> const compressor = APT::Configuration::getCompressors();
 312       for (std::vector<APT::Configuration::Compressor>::const_iterator c = compressor.begin();
 313            c != compressor.end(); ++c)
 314       {
 315          std::string filename = std::string(List[I]).append(Name).append(c->Extension);
 316          if (stat(filename.c_str(), &Buf) != 0)
 317             continue;
 318          Inodes[I] = Buf.st_ino;
 319          found = true;
 320          break;
 321       }
 322
 323       if (found == false)
 324       {
 325          _error->Errno("stat","Failed to stat %s%s",List[I].c_str(), Name);
 326          couldFindAllFiles = false;
 327          Inodes[I] = 0;
 328       }
 329    }
 330
 331    // Look for dups
 332    for (unsigned int I = 0; I != List.size(); I++)
 333    {
 334       if (Inodes[I] == 0)
 335          continue;
 336       for (unsigned int J = I+1; J < List.size(); J++)
 337       {
 338          // No match
 339          if (Inodes[J] == 0 || Inodes[J] != Inodes[I])
 340             continue;
 341
 342          // We score the two paths.. and erase one
 343          int ScoreA = Score(List[I]);
 344          int ScoreB = Score(List[J]);
 345          if (ScoreA < ScoreB)
 346          {
 347             List[I] = string();
 348             break;
 349          }
 350
 351          List[J] = string();
 352       }
 353    }
 354    delete[] Inodes;
 355
 356    // Wipe erased entries
 357    for (unsigned int I = 0; I < List.size();)
 358    {
 359       if (List[I].empty() == false)
 360          I++;
 361       else
 362          List.erase(List.begin()+I);
 363    }
 364
 365    return couldFindAllFiles;
 366 }
 367                                                                         /*}}}*/
 368 // ReduceSourceList - Takes the path list and reduces it                /*{{{*/
 369 // ---------------------------------------------------------------------
 370 /* This takes the list of source list expressed entires and collects
 371    similar ones to form a single entry for each dist */
 372 void pkgCdrom::ReduceSourcelist(string CD,vector<string> &List)
 373 {
 374    sort(List.begin(),List.end());
 375
 376    // Collect similar entries
 377    for (vector<string>::iterator I = List.begin(); I != List.end(); ++I)
 378    {
 379       // Find a space..
 380       string::size_type Space = (*I).find(' ');
 381       if (Space == string::npos)
 382          continue;
 383       string::size_type SSpace = (*I).find(' ',Space + 1);
 384       if (SSpace == string::npos)
 385          continue;
 386
 387       string Word1 = string(*I,Space,SSpace-Space);
 388       string Prefix = string(*I,0,Space);
 389       string Component = string(*I,SSpace);
 390       for (vector<string>::iterator J = List.begin(); J != I; ++J)
 391       {
 392          // Find a space..
 393          string::size_type Space2 = (*J).find(' ');
 394          if (Space2 == string::npos)
 395             continue;
 396          string::size_type SSpace2 = (*J).find(' ',Space2 + 1);
 397          if (SSpace2 == string::npos)
 398             continue;
 399
 400          if (string(*J,0,Space2) != Prefix)
 401             continue;
 402          if (string(*J,Space2,SSpace2-Space2) != Word1)
 403             continue;
 404
 405          string Component2 = string(*J, SSpace2) + " ";
 406          if (Component2.find(Component + " ") == std::string::npos)
 407             *J += Component;
 408          I->clear();
 409       }
 410    }
 411
 412    // Wipe erased entries
 413    for (unsigned int I = 0; I < List.size();)
 414    {
 415       if (List[I].empty() == false)
 416          I++;
 417       else
 418          List.erase(List.begin()+I);
 419    }
 420 }
 421                                                                         /*}}}*/
 422 // WriteDatabase - Write the CDROM Database file                        /*{{{*/
 423 // ---------------------------------------------------------------------
 424 /* We rewrite the configuration class associated with the cdrom database. */
 425 bool pkgCdrom::WriteDatabase(Configuration &Cnf)
 426 {
 427    string DFile = _config->FindFile("Dir::State::cdroms");
 428    string NewFile = DFile + ".new";
 429
 430    unlink(NewFile.c_str());
 431    ofstream Out(NewFile.c_str());
 432    if (!Out)
 433       return _error->Errno("ofstream::ofstream",
 434                            "Failed to open %s.new",DFile.c_str());
 435
 436    /* Write out all of the configuration directives by walking the
 437       configuration tree */
 438    Cnf.Dump(Out, NULL, "%f \"%v\";\n", false);
 439
 440    Out.close();
 441
 442    if (FileExists(DFile) == true)
 443       rename(DFile.c_str(), string(DFile + '~').c_str());
 444    if (rename(NewFile.c_str(),DFile.c_str()) != 0)
 445       return _error->Errno("rename","Failed to rename %s.new to %s",
 446                            DFile.c_str(),DFile.c_str());
 447
 448    return true;
 449 }
 450                                                                         /*}}}*/
 451 // WriteSourceList - Write an updated sourcelist                        /*{{{*/
 452 // ---------------------------------------------------------------------
 453 /* This reads the old source list and copies it into the new one. It
 454    appends the new CDROM entires just after the first block of comments.
 455    This places them first in the file. It also removes any old entries
 456    that were the same. */
 457 bool pkgCdrom::WriteSourceList(string Name,vector<string> &List,bool Source)
 458 {
 459    if (List.empty() == true)
 460       return true;
 461
 462    string File = _config->FindFile("Dir::Etc::sourcelist");
 463
 464    // Open the stream for reading
 465    ifstream F((FileExists(File)?File.c_str():"/dev/null"),
 466               ios::in );
 467    if (!F != 0)
 468       return _error->Errno("ifstream::ifstream","Opening %s",File.c_str());
 469
 470    string NewFile = File + ".new";
 471    unlink(NewFile.c_str());
 472    ofstream Out(NewFile.c_str());
 473    if (!Out)
 474       return _error->Errno("ofstream::ofstream",
 475                            "Failed to open %s.new",File.c_str());
 476
 477    // Create a short uri without the path
 478    string ShortURI = "cdrom:[" + Name + "]/";
 479    string ShortURI2 = "cdrom:" + Name + "/";     // For Compatibility
 480
 481    string Type;
 482    if (Source == true)
 483       Type = "deb-src";
 484    else
 485       Type = "deb";
 486
 487    char Buffer[300];
 488    int CurLine = 0;
 489    bool First = true;
 490    while (F.eof() == false)
 491    {
 492       F.getline(Buffer,sizeof(Buffer));
 493       CurLine++;
 494       if (F.fail() && !F.eof())
 495          return _error->Error(_("Line %u too long in source list %s."),
 496                               CurLine,File.c_str());
 497       _strtabexpand(Buffer,sizeof(Buffer));
 498       _strstrip(Buffer);
 499
 500       // Comment or blank
 501       if (Buffer[0] == '#' || Buffer[0] == 0)
 502       {
 503          Out << Buffer << endl;
 504          continue;
 505       }
 506
 507       if (First == true)
 508       {
 509          for (vector<string>::iterator I = List.begin(); I != List.end(); ++I)
 510          {
 511             string::size_type Space = (*I).find(' ');
 512             if (Space == string::npos)
 513                return _error->Error("Internal error");
 514             Out << Type << " cdrom:[" << Name << "]/" << string(*I,0,Space) <<
 515                " " << string(*I,Space+1) << endl;
 516          }
 517       }
 518       First = false;
 519
 520       // Grok it
 521       string cType;
 522       string URI;
 523       const char *C = Buffer;
 524       if (ParseQuoteWord(C,cType) == false ||
 525           ParseQuoteWord(C,URI) == false)
 526       {
 527          Out << Buffer << endl;
 528          continue;
 529       }
 530
 531       // Emit lines like this one
 532       if (cType != Type || (string(URI,0,ShortURI.length()) != ShortURI &&
 533           string(URI,0,ShortURI.length()) != ShortURI2))
 534       {
 535          Out << Buffer << endl;
 536          continue;
 537       }
 538    }
 539
 540    // Just in case the file was empty
 541    if (First == true)
 542    {
 543       for (vector<string>::iterator I = List.begin(); I != List.end(); ++I)
 544       {
 545          string::size_type Space = (*I).find(' ');
 546          if (Space == string::npos)
 547             return _error->Error("Internal error");
 548
 549          Out << "deb cdrom:[" << Name << "]/" << string(*I,0,Space) <<
 550             " " << string(*I,Space+1) << endl;
 551       }
 552    }
 553
 554    Out.close();
 555
 556    rename(File.c_str(),string(File + '~').c_str());
 557    if (rename(NewFile.c_str(),File.c_str()) != 0)
 558       return _error->Errno("rename","Failed to rename %s.new to %s",
 559                            File.c_str(),File.c_str());
 560
 561    return true;
 562 }
 563                                                                         /*}}}*/
 564 bool pkgCdrom::MountAndIdentCDROM(Configuration &Database, std::string &CDROM, std::string &ident, pkgCdromStatus * const log)/*{{{*/
 565 {
 566    // Startup
 567    CDROM = _config->FindDir("Acquire::cdrom::mount");
 568    if (CDROM[0] == '.')
 569       CDROM= SafeGetCWD() + '/' + CDROM;
 570
 571    if (log != NULL)
 572    {
 573       string msg;
 574       log->SetTotal(STEP_LAST);
 575       strprintf(msg, _("Using CD-ROM mount point %s\n"), CDROM.c_str());
 576       log->Update(msg, STEP_PREPARE);
 577    }
 578
 579    // Unmount the CD and get the user to put in the one they want
 580    if (_config->FindB("APT::CDROM::NoMount", false) == false)
 581    {
 582       if(log != NULL)
 583          log->Update(_("Unmounting CD-ROM\n"), STEP_UNMOUNT);
 584       UnmountCdrom(CDROM);
 585
 586       if(log != NULL)
 587       {
 588          log->Update(_("Waiting for disc...\n"), STEP_WAIT);
 589          if(!log->ChangeCdrom()) {
 590             // user aborted
 591             return false;
 592          }
 593       }
 594
 595       // Mount the new CDROM
 596       if(log != NULL)
 597          log->Update(_("Mounting CD-ROM...\n"), STEP_MOUNT);
 598
 599       if (MountCdrom(CDROM) == false)
 600          return _error->Error("Failed to mount the cdrom.");
 601    }
 602
 603    // Hash the CD to get an ID
 604    if (log != NULL)
 605       log->Update(_("Identifying.. "), STEP_IDENT);
 606
 607    if (IdentCdrom(CDROM,ident) == false)
 608    {
 609       ident = "";
 610       if (log != NULL)
 611          log->Update("\n");
 612       return false;
 613    }
 614
 615    if (log != NULL)
 616    {
 617       string msg;
 618       strprintf(msg, "[%s]\n", ident.c_str());
 619       log->Update(msg);
 620    }
 621
 622    // Read the database
 623    string DFile = _config->FindFile("Dir::State::cdroms");
 624    if (FileExists(DFile) == true)
 625    {
 626       if (ReadConfigFile(Database,DFile) == false)
 627          return _error->Error("Unable to read the cdrom database %s",
 628                               DFile.c_str());
 629    }
 630    return true;
 631 }
 632                                                                         /*}}}*/
 633 bool pkgCdrom::Ident(string &ident, pkgCdromStatus *log)                /*{{{*/
 634 {
 635    Configuration Database;
 636    std::string CDROM;
 637    if (MountAndIdentCDROM(Database, CDROM, ident, log) == false)
 638       return false;
 639
 640    if (log != NULL)
 641    {
 642       string msg;
 643       strprintf(msg, _("Stored label: %s\n"),
 644             Database.Find("CD::"+ident).c_str());
 645       log->Update(msg);
 646    }
 647
 648    // Unmount and finish
 649    if (_config->FindB("APT::CDROM::NoMount",false) == false)
 650    {
 651       if (log != NULL)
 652          log->Update(_("Unmounting CD-ROM...\n"), STEP_LAST);
 653       UnmountCdrom(CDROM);
 654    }
 655
 656    return true;
 657 }
 658                                                                         /*}}}*/
 659 bool pkgCdrom::Add(pkgCdromStatus *log)                                 /*{{{*/
 660 {
 661    Configuration Database;
 662    std::string ID, CDROM;
 663    if (MountAndIdentCDROM(Database, CDROM, ID, log) == false)
 664       return false;
 665
 666    if(log != NULL)
 667       log->Update(_("Scanning disc for index files..\n"),STEP_SCAN);
 668
 669    // Get the CD structure
 670    vector<string> List;
 671    vector<string> SourceList;
 672    vector<string> SigList;
 673    vector<string> TransList;
 674    string StartDir = SafeGetCWD();
 675    string InfoDir;
 676    if (FindPackages(CDROM,List,SourceList, SigList,TransList,InfoDir,log) == false)
 677    {
 678       if (log != NULL)
 679          log->Update("\n");
 680       return false;
 681    }
 682
 683    if (chdir(StartDir.c_str()) != 0)
 684       return _error->Errno("chdir","Unable to change to %s", StartDir.c_str());
 685
 686    if (_config->FindB("Debug::aptcdrom",false) == true)
 687    {
 688       cout << "I found (binary):" << endl;
 689       for (vector<string>::iterator I = List.begin(); I != List.end(); ++I)
 690          cout << *I << endl;
 691       cout << "I found (source):" << endl;
 692       for (vector<string>::iterator I = SourceList.begin(); I != SourceList.end(); ++I)
 693          cout << *I << endl;
 694       cout << "I found (Signatures):" << endl;
 695       for (vector<string>::iterator I = SigList.begin(); I != SigList.end(); ++I)
 696          cout << *I << endl;
 697    }
 698
 699    //log->Update(_("Cleaning package lists..."), STEP_CLEAN);
 700
 701    // Fix up the list
 702    DropBinaryArch(List);
 703    DropRepeats(List,"Packages");
 704    DropRepeats(SourceList,"Sources");
 705    // FIXME: We ignore stat() errors here as we usually have only one of those in use
 706    // This has little potencial to drop 'valid' stat() errors as we know that one of these
 707    // files need to exist, but it would be better if we would check it here
 708    _error->PushToStack();
 709    DropRepeats(SigList,"Release.gpg");
 710    DropRepeats(SigList,"InRelease");
 711    _error->RevertToStack();
 712    DropRepeats(TransList,"");
 713    if (_config->FindB("APT::CDROM::DropTranslation", true) == true)
 714       DropTranslation(TransList);
 715    if(log != NULL) {
 716       string msg;
 717       strprintf(msg, _("Found %zu package indexes, %zu source indexes, "
 718                       "%zu translation indexes and %zu signatures\n"),
 719                List.size(), SourceList.size(), TransList.size(),
 720                SigList.size());
 721       log->Update(msg, STEP_SCAN);
 722    }
 723
 724    if (List.empty() == true && SourceList.empty() == true)
 725    {
 726       if (_config->FindB("APT::CDROM::NoMount",false) == false)
 727          UnmountCdrom(CDROM);
 728       return _error->Error(_("Unable to locate any package files, perhaps this is not a Debian Disc or the wrong architecture?"));
 729    }
 730
 731    // Check if the CD is in the database
 732    string Name;
 733    if (Database.Exists("CD::" + ID) == false ||
 734        _config->FindB("APT::CDROM::Rename",false) == true)
 735    {
 736       // Try to use the CDs label if at all possible
 737       if (InfoDir.empty() == false &&
 738           FileExists(InfoDir + "/info") == true)
 739       {
 740          ifstream F(string(InfoDir + "/info").c_str());
 741          if (!F == 0)
 742             getline(F,Name);
 743
 744          if (Name.empty() == false)
 745          {
 746             // Escape special characters
 747             string::iterator J = Name.begin();
 748             for (; J != Name.end(); ++J)
 749                if (*J == '"' || *J == ']' || *J == '[')
 750                   *J = '_';
 751
 752             if(log != NULL)
 753             {
 754                string msg;
 755                strprintf(msg, _("Found label '%s'\n"), Name.c_str());
 756                log->Update(msg);
 757             }
 758             Database.Set("CD::" + ID + "::Label",Name);
 759          }
 760       }
 761
 762       if (_config->FindB("APT::CDROM::Rename",false) == true ||
 763           Name.empty() == true)
 764       {
 765          if(log == NULL)
 766          {
 767             if (_config->FindB("APT::CDROM::NoMount",false) == false)
 768                UnmountCdrom(CDROM);
 769             return _error->Error("No disc name found and no way to ask for it");
 770          }
 771
 772          while(true) {
 773             if(!log->AskCdromName(Name)) {
 774                // user canceld
 775                return false;
 776             }
 777             cout << "Name: '" << Name << "'" << endl;
 778
 779             if (Name.empty() == false &&
 780                 Name.find('"') == string::npos &&
 781                 Name.find('[') == string::npos &&
 782                 Name.find(']') == string::npos)
 783                break;
 784             log->Update(_("That is not a valid name, try again.\n"));
 785          }
 786       }
 787    }
 788    else
 789       Name = Database.Find("CD::" + ID);
 790
 791    // Escape special characters
 792    string::iterator J = Name.begin();
 793    for (; J != Name.end(); ++J)
 794       if (*J == '"' || *J == ']' || *J == '[')
 795          *J = '_';
 796
 797    Database.Set("CD::" + ID,Name);
 798    if(log != NULL)
 799    {
 800       string msg;
 801       strprintf(msg, _("This disc is called: \n'%s'\n"), Name.c_str());
 802       log->Update(msg);
 803       log->Update(_("Copying package lists..."), STEP_COPY);
 804    }
 805
 806    // check for existence and possibly create state directory for copying
 807    string const listDir = _config->FindDir("Dir::State::lists");
 808    string const partialListDir = listDir + "partial/";
 809    if (CreateAPTDirectoryIfNeeded(_config->FindDir("Dir::State"), partialListDir) == false &&
 810        CreateAPTDirectoryIfNeeded(listDir, partialListDir) == false)
 811       return _error->Errno("cdrom", _("List directory %spartial is missing."), listDir.c_str());
 812
 813    // take care of the signatures and copy them if they are ok
 814    // (we do this before PackageCopy as it modifies "List" and "SourceList")
 815    SigVerify SignVerify;
 816    SignVerify.CopyAndVerify(CDROM, Name, SigList, List, SourceList);
 817
 818    // Copy the package files to the state directory
 819    PackageCopy Copy;
 820    SourceCopy SrcCopy;
 821    TranslationsCopy TransCopy;
 822    if (Copy.CopyPackages(CDROM,Name,List, log) == false ||
 823        SrcCopy.CopyPackages(CDROM,Name,SourceList, log) == false ||
 824        TransCopy.CopyTranslations(CDROM,Name,TransList, log) == false)
 825       return false;
 826
 827    // reduce the List so that it takes less space in sources.list
 828    ReduceSourcelist(CDROM,List);
 829    ReduceSourcelist(CDROM,SourceList);
 830
 831    // Write the database and sourcelist
 832    if (_config->FindB("APT::cdrom::NoAct",false) == false)
 833    {
 834       if (WriteDatabase(Database) == false)
 835          return false;
 836
 837       if(log != NULL)
 838          log->Update(_("Writing new source list\n"), STEP_WRITE);
 839       if (WriteSourceList(Name,List,false) == false ||
 840           WriteSourceList(Name,SourceList,true) == false)
 841          return false;
 842    }
 843
 844    // Print the sourcelist entries
 845    if(log != NULL)
 846       log->Update(_("Source list entries for this disc are:\n"));
 847
 848    for (vector<string>::iterator I = List.begin(); I != List.end(); ++I)
 849    {
 850       string::size_type Space = (*I).find(' ');
 851       if (Space == string::npos)
 852       {
 853          if (_config->FindB("APT::CDROM::NoMount",false) == false)
 854             UnmountCdrom(CDROM);
 855          return _error->Error("Internal error");
 856       }
 857
 858       if(log != NULL)
 859       {
 860          stringstream msg;
 861          msg << "deb cdrom:[" << Name << "]/" << string(*I,0,Space) <<
 862             " " << string(*I,Space+1) << endl;
 863          log->Update(msg.str());
 864       }
 865    }
 866
 867    for (vector<string>::iterator I = SourceList.begin(); I != SourceList.end(); ++I)
 868    {
 869       string::size_type Space = (*I).find(' ');
 870       if (Space == string::npos)
 871       {
 872          if (_config->FindB("APT::CDROM::NoMount",false) == false)
 873             UnmountCdrom(CDROM);
 874          return _error->Error("Internal error");
 875       }
 876
 877       if(log != NULL) {
 878          stringstream msg;
 879          msg << "deb-src cdrom:[" << Name << "]/" << string(*I,0,Space) <<
 880             " " << string(*I,Space+1) << endl;
 881          log->Update(msg.str());
 882       }
 883    }
 884
 885    // Unmount and finish
 886    if (_config->FindB("APT::CDROM::NoMount",false) == false) {
 887       if (log != NULL)
 888          log->Update(_("Unmounting CD-ROM...\n"), STEP_LAST);
 889       UnmountCdrom(CDROM);
 890    }
 891
 892    return true;
 893 }
 894                                                                         /*}}}*/
 895 pkgUdevCdromDevices::pkgUdevCdromDevices()                              /*{{{*/
 896    : libudev_handle(NULL)
 897 {
 898
 899 }
 900                                                                         /*}}}*/
 901
 902 bool
 903 pkgUdevCdromDevices::Dlopen()                                           /*{{{*/
 904 {
 905    // alread open
 906    if(libudev_handle != NULL)
 907       return true;
 908
 909    // see if we can get libudev
 910    void *h = ::dlopen("libudev.so.0", RTLD_LAZY);
 911    if(h == NULL)
 912       return false;
 913
 914    // get the pointers to the udev structs
 915    libudev_handle = h;
 916    udev_new = (udev* (*)(void)) dlsym(h, "udev_new");
 917    udev_enumerate_add_match_property = (int (*)(udev_enumerate*, const char*, const char*))dlsym(h, "udev_enumerate_add_match_property");
 918    udev_enumerate_add_match_sysattr = (int (*)(udev_enumerate*, const char*, const char*))dlsym(h, "udev_enumerate_add_match_sysattr");
 919    udev_enumerate_scan_devices = (int (*)(udev_enumerate*))dlsym(h, "udev_enumerate_scan_devices");
 920    udev_enumerate_get_list_entry = (udev_list_entry* (*)(udev_enumerate*))dlsym(h, "udev_enumerate_get_list_entry");
 921    udev_device_new_from_syspath = (udev_device* (*)(udev*, const char*))dlsym(h, "udev_device_new_from_syspath");
 922    udev_enumerate_get_udev = (udev* (*)(udev_enumerate*))dlsym(h, "udev_enumerate_get_udev");
 923    udev_list_entry_get_name = (const char* (*)(udev_list_entry*))dlsym(h, "udev_list_entry_get_name");
 924    udev_device_get_devnode = (const char* (*)(udev_device*))dlsym(h, "udev_device_get_devnode");
 925    udev_enumerate_new = (udev_enumerate* (*)(udev*))dlsym(h, "udev_enumerate_new");
 926    udev_list_entry_get_next = (udev_list_entry* (*)(udev_list_entry*))dlsym(h, "udev_list_entry_get_next");
 927    udev_device_get_property_value = (const char* (*)(udev_device *, const char *))dlsym(h, "udev_device_get_property_value");
 928
 929    return true;
 930 }
 931                                                                         /*}}}*/
 932                                                                         /*{{{*/
 933 // convenience interface, this will just call ScanForRemovable
 934 vector<CdromDevice>
 935 pkgUdevCdromDevices::Scan()
 936 {
 937    bool CdromOnly = _config->FindB("APT::cdrom::CdromOnly", true);
 938    return ScanForRemovable(CdromOnly);
 939 };
 940                                                                         /*}}}*/
 941                                                                         /*{{{*/
 942 vector<CdromDevice>
 943 pkgUdevCdromDevices::ScanForRemovable(bool CdromOnly)
 944 {
 945    vector<CdromDevice> cdrom_devices;
 946    struct udev_enumerate *enumerate;
 947    struct udev_list_entry *l, *devices;
 948    struct udev *udev_ctx;
 949
 950    if(libudev_handle == NULL)
 951       return cdrom_devices;
 952
 953    udev_ctx = udev_new();
 954    enumerate = udev_enumerate_new (udev_ctx);
 955    if (CdromOnly)
 956       udev_enumerate_add_match_property(enumerate, "ID_CDROM", "1");
 957    else {
 958       udev_enumerate_add_match_sysattr(enumerate, "removable", "1");
 959    }
 960
 961    udev_enumerate_scan_devices (enumerate);
 962    devices = udev_enumerate_get_list_entry (enumerate);
 963    for (l = devices; l != NULL; l = udev_list_entry_get_next (l))
 964    {
 965       CdromDevice cdrom;
 966       struct udev_device *udevice;
 967       udevice = udev_device_new_from_syspath (udev_enumerate_get_udev (enumerate), udev_list_entry_get_name (l));
 968       if (udevice == NULL)
 969          continue;
 970       const char* devnode = udev_device_get_devnode(udevice);
 971
 972       // try fstab_dir first
 973       string mountpath;
 974       const char* mp = udev_device_get_property_value(udevice, "FSTAB_DIR");
 975       if (mp)
 976          mountpath = string(mp);
 977       else
 978          mountpath = FindMountPointForDevice(devnode);
 979
 980       // fill in the struct
 981       cdrom.DeviceName = string(devnode);
 982       if (mountpath != "") {
 983          cdrom.MountPath = mountpath;
 984          string s = string(mountpath);
 985          cdrom.Mounted = IsMounted(s);
 986       } else {
 987          cdrom.Mounted = false;
 988          cdrom.MountPath = "";
 989       }
 990       cdrom_devices.push_back(cdrom);
 991    }
 992    return cdrom_devices;
 993 }
 994                                                                         /*}}}*/
 995
 996 pkgUdevCdromDevices::~pkgUdevCdromDevices()                             /*{{{*/
 997 {
 998    if (libudev_handle != NULL)
 999       dlclose(libudev_handle);
1000 }
1001                                                                         /*}}}*/