apt-pkg/cdrom.cc

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