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 // DropRepeats - Drop repeated files resulting from symlinks            /*{{{*/
 276 // ---------------------------------------------------------------------
 277 /* Here we go and stat every file that we found and strip dup inodes. */
 278 bool pkgCdrom::DropRepeats(vector<string> &List,const char *Name)
 279 {
 280    bool couldFindAllFiles = true;
 281    // Get a list of all the inodes
 282    ino_t *Inodes = new ino_t[List.size()];
 283    for (unsigned int I = 0; I != List.size(); ++I)
 284    {
 285       struct stat Buf;
 286       bool found = false;
 287
 288       std::vector<APT::Configuration::Compressor> const compressor = APT::Configuration::getCompressors();
 289       for (std::vector<APT::Configuration::Compressor>::const_iterator c = compressor.begin();
 290            c != compressor.end(); ++c)
 291       {
 292          std::string filename = std::string(List[I]).append(Name).append(c->Extension);
 293          if (stat(filename.c_str(), &Buf) != 0)
 294             continue;
 295          Inodes[I] = Buf.st_ino;
 296          found = true;
 297          break;
 298       }
 299
 300       if (found == false)
 301       {
 302          _error->Errno("stat","Failed to stat %s%s",List[I].c_str(), Name);
 303          couldFindAllFiles = false;
 304          Inodes[I] = 0;
 305       }
 306    }
 307
 308    // Look for dups
 309    for (unsigned int I = 0; I != List.size(); I++)
 310    {
 311       if (Inodes[I] == 0)
 312          continue;
 313       for (unsigned int J = I+1; J < List.size(); J++)
 314       {
 315          // No match
 316          if (Inodes[J] == 0 || Inodes[J] != Inodes[I])
 317             continue;
 318
 319          // We score the two paths.. and erase one
 320          int ScoreA = Score(List[I]);
 321          int ScoreB = Score(List[J]);
 322          if (ScoreA < ScoreB)
 323          {
 324             List[I] = string();
 325             break;
 326          }
 327
 328          List[J] = string();
 329       }
 330    }
 331    delete[] Inodes;
 332
 333    // Wipe erased entries
 334    for (unsigned int I = 0; I < List.size();)
 335    {
 336       if (List[I].empty() == false)
 337          I++;
 338       else
 339          List.erase(List.begin()+I);
 340    }
 341
 342    return couldFindAllFiles;
 343 }
 344                                                                         /*}}}*/
 345 // ReduceSourceList - Takes the path list and reduces it                /*{{{*/
 346 // ---------------------------------------------------------------------
 347 /* This takes the list of source list expressed entires and collects
 348    similar ones to form a single entry for each dist */
 349 void pkgCdrom::ReduceSourcelist(string CD,vector<string> &List)
 350 {
 351    sort(List.begin(),List.end());
 352
 353    // Collect similar entries
 354    for (vector<string>::iterator I = List.begin(); I != List.end(); ++I)
 355    {
 356       // Find a space..
 357       string::size_type Space = (*I).find(' ');
 358       if (Space == string::npos)
 359          continue;
 360       string::size_type SSpace = (*I).find(' ',Space + 1);
 361       if (SSpace == string::npos)
 362          continue;
 363
 364       string Word1 = string(*I,Space,SSpace-Space);
 365       string Prefix = string(*I,0,Space);
 366       for (vector<string>::iterator J = List.begin(); J != I; ++J)
 367       {
 368          // Find a space..
 369          string::size_type Space2 = (*J).find(' ');
 370          if (Space2 == string::npos)
 371             continue;
 372          string::size_type SSpace2 = (*J).find(' ',Space2 + 1);
 373          if (SSpace2 == string::npos)
 374             continue;
 375
 376          if (string(*J,0,Space2) != Prefix)
 377             continue;
 378          if (string(*J,Space2,SSpace2-Space2) != Word1)
 379             continue;
 380
 381          *J += string(*I,SSpace);
 382          *I = string();
 383       }
 384    }
 385
 386    // Wipe erased entries
 387    for (unsigned int I = 0; I < List.size();)
 388    {
 389       if (List[I].empty() == false)
 390          I++;
 391       else
 392          List.erase(List.begin()+I);
 393    }
 394 }
 395                                                                         /*}}}*/
 396 // WriteDatabase - Write the CDROM Database file                        /*{{{*/
 397 // ---------------------------------------------------------------------
 398 /* We rewrite the configuration class associated with the cdrom database. */
 399 bool pkgCdrom::WriteDatabase(Configuration &Cnf)
 400 {
 401    string DFile = _config->FindFile("Dir::State::cdroms");
 402    string NewFile = DFile + ".new";
 403
 404    unlink(NewFile.c_str());
 405    ofstream Out(NewFile.c_str());
 406    if (!Out)
 407       return _error->Errno("ofstream::ofstream",
 408                            "Failed to open %s.new",DFile.c_str());
 409
 410    /* Write out all of the configuration directives by walking the
 411       configuration tree */
 412    const Configuration::Item *Top = Cnf.Tree(0);
 413    for (; Top != 0;)
 414    {
 415       // Print the config entry
 416       if (Top->Value.empty() == false)
 417          Out <<  Top->FullTag() + " \"" << Top->Value << "\";" << endl;
 418
 419       if (Top->Child != 0)
 420       {
 421          Top = Top->Child;
 422          continue;
 423       }
 424
 425       while (Top != 0 && Top->Next == 0)
 426          Top = Top->Parent;
 427       if (Top != 0)
 428          Top = Top->Next;
 429    }
 430
 431    Out.close();
 432
 433    link(DFile.c_str(),string(DFile + '~').c_str());
 434    if (rename(NewFile.c_str(),DFile.c_str()) != 0)
 435       return _error->Errno("rename","Failed to rename %s.new to %s",
 436                            DFile.c_str(),DFile.c_str());
 437
 438    return true;
 439 }
 440                                                                         /*}}}*/
 441 // WriteSourceList - Write an updated sourcelist                        /*{{{*/
 442 // ---------------------------------------------------------------------
 443 /* This reads the old source list and copies it into the new one. It
 444    appends the new CDROM entires just after the first block of comments.
 445    This places them first in the file. It also removes any old entries
 446    that were the same. */
 447 bool pkgCdrom::WriteSourceList(string Name,vector<string> &List,bool Source)
 448 {
 449    if (List.empty() == true)
 450       return true;
 451
 452    string File = _config->FindFile("Dir::Etc::sourcelist");
 453
 454    // Open the stream for reading
 455    ifstream F((FileExists(File)?File.c_str():"/dev/null"),
 456               ios::in );
 457    if (!F != 0)
 458       return _error->Errno("ifstream::ifstream","Opening %s",File.c_str());
 459
 460    string NewFile = File + ".new";
 461    unlink(NewFile.c_str());
 462    ofstream Out(NewFile.c_str());
 463    if (!Out)
 464       return _error->Errno("ofstream::ofstream",
 465                            "Failed to open %s.new",File.c_str());
 466
 467    // Create a short uri without the path
 468    string ShortURI = "cdrom:[" + Name + "]/";
 469    string ShortURI2 = "cdrom:" + Name + "/";     // For Compatibility
 470
 471    string Type;
 472    if (Source == true)
 473       Type = "deb-src";
 474    else
 475       Type = "deb";
 476
 477    char Buffer[300];
 478    int CurLine = 0;
 479    bool First = true;
 480    while (F.eof() == false)
 481    {
 482       F.getline(Buffer,sizeof(Buffer));
 483       CurLine++;
 484       if (F.fail() && !F.eof())
 485          return _error->Error(_("Line %u too long in source list %s."),
 486                               CurLine,File.c_str());
 487       _strtabexpand(Buffer,sizeof(Buffer));
 488       _strstrip(Buffer);
 489
 490       // Comment or blank
 491       if (Buffer[0] == '#' || Buffer[0] == 0)
 492       {
 493          Out << Buffer << endl;
 494          continue;
 495       }
 496
 497       if (First == true)
 498       {
 499          for (vector<string>::iterator I = List.begin(); I != List.end(); ++I)
 500          {
 501             string::size_type Space = (*I).find(' ');
 502             if (Space == string::npos)
 503                return _error->Error("Internal error");
 504             Out << Type << " cdrom:[" << Name << "]/" << string(*I,0,Space) <<
 505                " " << string(*I,Space+1) << endl;
 506          }
 507       }
 508       First = false;
 509
 510       // Grok it
 511       string cType;
 512       string URI;
 513       const char *C = Buffer;
 514       if (ParseQuoteWord(C,cType) == false ||
 515           ParseQuoteWord(C,URI) == false)
 516       {
 517          Out << Buffer << endl;
 518          continue;
 519       }
 520
 521       // Emit lines like this one
 522       if (cType != Type || (string(URI,0,ShortURI.length()) != ShortURI &&
 523           string(URI,0,ShortURI.length()) != ShortURI2))
 524       {
 525          Out << Buffer << endl;
 526          continue;
 527       }
 528    }
 529
 530    // Just in case the file was empty
 531    if (First == true)
 532    {
 533       for (vector<string>::iterator I = List.begin(); I != List.end(); ++I)
 534       {
 535          string::size_type Space = (*I).find(' ');
 536          if (Space == string::npos)
 537             return _error->Error("Internal error");
 538
 539          Out << "deb cdrom:[" << Name << "]/" << string(*I,0,Space) <<
 540             " " << string(*I,Space+1) << endl;
 541       }
 542    }
 543
 544    Out.close();
 545
 546    rename(File.c_str(),string(File + '~').c_str());
 547    if (rename(NewFile.c_str(),File.c_str()) != 0)
 548       return _error->Errno("rename","Failed to rename %s.new to %s",
 549                            File.c_str(),File.c_str());
 550
 551    return true;
 552 }
 553                                                                         /*}}}*/
 554 bool pkgCdrom::Ident(string &ident, pkgCdromStatus *log)                /*{{{*/
 555 {
 556    stringstream msg;
 557
 558    // Startup
 559    string CDROM = _config->FindDir("Acquire::cdrom::mount");
 560    if (CDROM[0] == '.')
 561       CDROM= SafeGetCWD() + '/' + CDROM;
 562
 563    if (log != NULL)
 564    {
 565       msg.str("");
 566       ioprintf(msg, _("Using CD-ROM mount point %s\nMounting CD-ROM\n"),
 567                       CDROM.c_str());
 568       log->Update(msg.str());
 569    }
 570    if (MountCdrom(CDROM) == false)
 571       return _error->Error("Failed to mount the cdrom.");
 572
 573    // Hash the CD to get an ID
 574    if (log != NULL)
 575       log->Update(_("Identifying.. "));
 576
 577
 578    if (IdentCdrom(CDROM,ident) == false)
 579    {
 580       ident = "";
 581       return false;
 582    }
 583
 584    if (log != NULL)
 585    {
 586       msg.str("");
 587       ioprintf(msg, "[%s]\n",ident.c_str());
 588       log->Update(msg.str());
 589    }
 590
 591    // Read the database
 592    Configuration Database;
 593    string DFile = _config->FindFile("Dir::State::cdroms");
 594    if (FileExists(DFile) == true)
 595    {
 596       if (ReadConfigFile(Database,DFile) == false)
 597          return _error->Error("Unable to read the cdrom database %s",
 598                               DFile.c_str());
 599    }
 600    if (log != NULL)
 601    {
 602       msg.str("");
 603       ioprintf(msg, _("Stored label: %s\n"),
 604       Database.Find("CD::"+ident).c_str());
 605       log->Update(msg.str());
 606    }
 607
 608    // Unmount and finish
 609    if (_config->FindB("APT::CDROM::NoMount",false) == false)
 610    {
 611       if (log != NULL)
 612          log->Update(_("Unmounting CD-ROM...\n"), STEP_LAST);
 613       UnmountCdrom(CDROM);
 614    }
 615
 616    return true;
 617 }
 618                                                                         /*}}}*/
 619 bool pkgCdrom::Add(pkgCdromStatus *log)                                 /*{{{*/
 620 {
 621    stringstream msg;
 622
 623    // Startup
 624    string CDROM = _config->FindDir("Acquire::cdrom::mount");
 625    if (CDROM[0] == '.')
 626       CDROM= SafeGetCWD() + '/' + CDROM;
 627
 628    if(log != NULL)
 629    {
 630       log->SetTotal(STEP_LAST);
 631       msg.str("");
 632       ioprintf(msg, _("Using CD-ROM mount point %s\n"), CDROM.c_str());
 633       log->Update(msg.str(), STEP_PREPARE);
 634    }
 635
 636    // Read the database
 637    Configuration Database;
 638    string DFile = _config->FindFile("Dir::State::cdroms");
 639    if (FileExists(DFile) == true)
 640    {
 641       if (ReadConfigFile(Database,DFile) == false)
 642          return _error->Error("Unable to read the cdrom database %s",
 643                               DFile.c_str());
 644    }
 645
 646    // Unmount the CD and get the user to put in the one they want
 647    if (_config->FindB("APT::CDROM::NoMount",false) == false)
 648    {
 649       if(log != NULL)
 650          log->Update(_("Unmounting CD-ROM\n"), STEP_UNMOUNT);
 651       UnmountCdrom(CDROM);
 652
 653       if(log != NULL)
 654       {
 655          log->Update(_("Waiting for disc...\n"), STEP_WAIT);
 656          if(!log->ChangeCdrom()) {
 657             // user aborted
 658             return false;
 659          }
 660       }
 661
 662       // Mount the new CDROM
 663       if(log != NULL)
 664          log->Update(_("Mounting CD-ROM...\n"), STEP_MOUNT);
 665
 666       if (MountCdrom(CDROM) == false)
 667          return _error->Error("Failed to mount the cdrom.");
 668    }
 669
 670    // Hash the CD to get an ID
 671    if(log != NULL)
 672       log->Update(_("Identifying.. "), STEP_IDENT);
 673    string ID;
 674    if (IdentCdrom(CDROM,ID) == false)
 675    {
 676       if (log != NULL)
 677          log->Update("\n");
 678       return false;
 679    }
 680    if(log != NULL)
 681    {
 682       log->Update("["+ID+"]\n");
 683       log->Update(_("Scanning disc for index files..\n"),STEP_SCAN);
 684    }
 685
 686    // Get the CD structure
 687    vector<string> List;
 688    vector<string> SourceList;
 689    vector<string> SigList;
 690    vector<string> TransList;
 691    string StartDir = SafeGetCWD();
 692    string InfoDir;
 693    if (FindPackages(CDROM,List,SourceList, SigList,TransList,InfoDir,log) == false)
 694    {
 695       if (log != NULL)
 696          log->Update("\n");
 697       return false;
 698    }
 699
 700    chdir(StartDir.c_str());
 701
 702    if (_config->FindB("Debug::aptcdrom",false) == true)
 703    {
 704       cout << "I found (binary):" << endl;
 705       for (vector<string>::iterator I = List.begin(); I != List.end(); ++I)
 706          cout << *I << endl;
 707       cout << "I found (source):" << endl;
 708       for (vector<string>::iterator I = SourceList.begin(); I != SourceList.end(); ++I)
 709          cout << *I << endl;
 710       cout << "I found (Signatures):" << endl;
 711       for (vector<string>::iterator I = SigList.begin(); I != SigList.end(); ++I)
 712          cout << *I << endl;
 713    }
 714
 715    //log->Update(_("Cleaning package lists..."), STEP_CLEAN);
 716
 717    // Fix up the list
 718    DropBinaryArch(List);
 719    DropRepeats(List,"Packages");
 720    DropRepeats(SourceList,"Sources");
 721    // FIXME: We ignore stat() errors here as we usually have only one of those in use
 722    // This has little potencial to drop 'valid' stat() errors as we know that one of these
 723    // files need to exist, but it would be better if we would check it here
 724    _error->PushToStack();
 725    DropRepeats(SigList,"Release.gpg");
 726    DropRepeats(SigList,"InRelease");
 727    _error->RevertToStack();
 728    DropRepeats(TransList,"");
 729    if(log != NULL) {
 730       msg.str("");
 731       ioprintf(msg, _("Found %zu package indexes, %zu source indexes, "
 732                       "%zu translation indexes and %zu signatures\n"),
 733                List.size(), SourceList.size(), TransList.size(),
 734                SigList.size());
 735       log->Update(msg.str(), STEP_SCAN);
 736    }
 737
 738    if (List.empty() == true && SourceList.empty() == true)
 739    {
 740       if (_config->FindB("APT::CDROM::NoMount",false) == false)
 741          UnmountCdrom(CDROM);
 742       return _error->Error(_("Unable to locate any package files, perhaps this is not a Debian Disc or the wrong architecture?"));
 743    }
 744
 745    // Check if the CD is in the database
 746    string Name;
 747    if (Database.Exists("CD::" + ID) == false ||
 748        _config->FindB("APT::CDROM::Rename",false) == true)
 749    {
 750       // Try to use the CDs label if at all possible
 751       if (InfoDir.empty() == false &&
 752           FileExists(InfoDir + "/info") == true)
 753       {
 754          ifstream F(string(InfoDir + "/info").c_str());
 755          if (!F == 0)
 756             getline(F,Name);
 757
 758          if (Name.empty() == false)
 759          {
 760             // Escape special characters
 761             string::iterator J = Name.begin();
 762             for (; J != Name.end(); ++J)
 763                if (*J == '"' || *J == ']' || *J == '[')
 764                   *J = '_';
 765
 766             if(log != NULL)
 767             {
 768                msg.str("");
 769                ioprintf(msg, _("Found label '%s'\n"), Name.c_str());
 770                log->Update(msg.str());
 771             }
 772             Database.Set("CD::" + ID + "::Label",Name);
 773          }
 774       }
 775
 776       if (_config->FindB("APT::CDROM::Rename",false) == true ||
 777           Name.empty() == true)
 778       {
 779          if(log == NULL)
 780          {
 781             if (_config->FindB("APT::CDROM::NoMount",false) == false)
 782                UnmountCdrom(CDROM);
 783             return _error->Error("No disc name found and no way to ask for it");
 784          }
 785
 786          while(true) {
 787             if(!log->AskCdromName(Name)) {
 788                // user canceld
 789                return false;
 790             }
 791             cout << "Name: '" << Name << "'" << endl;
 792
 793             if (Name.empty() == false &&
 794                 Name.find('"') == string::npos &&
 795                 Name.find('[') == string::npos &&
 796                 Name.find(']') == string::npos)
 797                break;
 798             log->Update(_("That is not a valid name, try again.\n"));
 799          }
 800       }
 801    }
 802    else
 803       Name = Database.Find("CD::" + ID);
 804
 805    // Escape special characters
 806    string::iterator J = Name.begin();
 807    for (; J != Name.end(); ++J)
 808       if (*J == '"' || *J == ']' || *J == '[')
 809          *J = '_';
 810
 811    Database.Set("CD::" + ID,Name);
 812    if(log != NULL)
 813    {
 814       msg.str("");
 815       ioprintf(msg, _("This disc is called: \n'%s'\n"), Name.c_str());
 816       log->Update(msg.str());
 817       log->Update(_("Copying package lists..."), STEP_COPY);
 818    }
 819    // take care of the signatures and copy them if they are ok
 820    // (we do this before PackageCopy as it modifies "List" and "SourceList")
 821    SigVerify SignVerify;
 822    SignVerify.CopyAndVerify(CDROM, Name, SigList, List, SourceList);
 823
 824    // Copy the package files to the state directory
 825    PackageCopy Copy;
 826    SourceCopy SrcCopy;
 827    TranslationsCopy TransCopy;
 828    if (Copy.CopyPackages(CDROM,Name,List, log) == false ||
 829        SrcCopy.CopyPackages(CDROM,Name,SourceList, log) == false ||
 830        TransCopy.CopyTranslations(CDROM,Name,TransList, log) == false)
 831       return false;
 832
 833    // reduce the List so that it takes less space in sources.list
 834    ReduceSourcelist(CDROM,List);
 835    ReduceSourcelist(CDROM,SourceList);
 836
 837    // Write the database and sourcelist
 838    if (_config->FindB("APT::cdrom::NoAct",false) == false)
 839    {
 840       if (WriteDatabase(Database) == false)
 841          return false;
 842
 843       if(log != NULL)
 844          log->Update(_("Writing new source list\n"), STEP_WRITE);
 845       if (WriteSourceList(Name,List,false) == false ||
 846           WriteSourceList(Name,SourceList,true) == false)
 847          return false;
 848    }
 849
 850    // Print the sourcelist entries
 851    if(log != NULL)
 852       log->Update(_("Source list entries for this disc are:\n"));
 853
 854    for (vector<string>::iterator I = List.begin(); I != List.end(); ++I)
 855    {
 856       string::size_type Space = (*I).find(' ');
 857       if (Space == string::npos)
 858       {
 859          if (_config->FindB("APT::CDROM::NoMount",false) == false)
 860             UnmountCdrom(CDROM);
 861          return _error->Error("Internal error");
 862       }
 863
 864       if(log != NULL)
 865       {
 866          msg.str("");
 867          msg << "deb cdrom:[" << Name << "]/" << string(*I,0,Space) <<
 868             " " << string(*I,Space+1) << endl;
 869          log->Update(msg.str());
 870       }
 871    }
 872
 873    for (vector<string>::iterator I = SourceList.begin(); I != SourceList.end(); ++I)
 874    {
 875       string::size_type Space = (*I).find(' ');
 876       if (Space == string::npos)
 877       {
 878          if (_config->FindB("APT::CDROM::NoMount",false) == false)
 879             UnmountCdrom(CDROM);
 880          return _error->Error("Internal error");
 881       }
 882
 883       if(log != NULL) {
 884          msg.str("");
 885          msg << "deb-src cdrom:[" << Name << "]/" << string(*I,0,Space) <<
 886             " " << string(*I,Space+1) << endl;
 887          log->Update(msg.str());
 888       }
 889    }
 890
 891    // Unmount and finish
 892    if (_config->FindB("APT::CDROM::NoMount",false) == false) {
 893       if (log != NULL)
 894          log->Update(_("Unmounting CD-ROM...\n"), STEP_LAST);
 895       UnmountCdrom(CDROM);
 896    }
 897
 898    return true;
 899 }
 900                                                                         /*}}}*/
 901 pkgUdevCdromDevices::pkgUdevCdromDevices()                              /*{{{*/
 902    : libudev_handle(NULL)
 903 {
 904
 905 }
 906                                                                         /*}}}*/
 907
 908 bool
 909 pkgUdevCdromDevices::Dlopen()                                           /*{{{*/
 910 {
 911    // alread open
 912    if(libudev_handle != NULL)
 913       return true;
 914
 915    // see if we can get libudev
 916    void *h = ::dlopen("libudev.so.0", RTLD_LAZY);
 917    if(h == NULL)
 918       return false;
 919
 920    // get the pointers to the udev structs
 921    libudev_handle = h;
 922    udev_new = (udev* (*)(void)) dlsym(h, "udev_new");
 923    udev_enumerate_add_match_property = (int (*)(udev_enumerate*, const char*, const char*))dlsym(h, "udev_enumerate_add_match_property");
 924    udev_enumerate_add_match_sysattr = (int (*)(udev_enumerate*, const char*, const char*))dlsym(h, "udev_enumerate_add_match_sysattr");
 925    udev_enumerate_scan_devices = (int (*)(udev_enumerate*))dlsym(h, "udev_enumerate_scan_devices");
 926    udev_enumerate_get_list_entry = (udev_list_entry* (*)(udev_enumerate*))dlsym(h, "udev_enumerate_get_list_entry");
 927    udev_device_new_from_syspath = (udev_device* (*)(udev*, const char*))dlsym(h, "udev_device_new_from_syspath");
 928    udev_enumerate_get_udev = (udev* (*)(udev_enumerate*))dlsym(h, "udev_enumerate_get_udev");
 929    udev_list_entry_get_name = (const char* (*)(udev_list_entry*))dlsym(h, "udev_list_entry_get_name");
 930    udev_device_get_devnode = (const char* (*)(udev_device*))dlsym(h, "udev_device_get_devnode");
 931    udev_enumerate_new = (udev_enumerate* (*)(udev*))dlsym(h, "udev_enumerate_new");
 932    udev_list_entry_get_next = (udev_list_entry* (*)(udev_list_entry*))dlsym(h, "udev_list_entry_get_next");
 933    udev_device_get_property_value = (const char* (*)(udev_device *, const char *))dlsym(h, "udev_device_get_property_value");
 934
 935    return true;
 936 }
 937                                                                         /*}}}*/
 938                                                                         /*{{{*/
 939 // convenience interface, this will just call ScanForRemovable
 940 vector<CdromDevice>
 941 pkgUdevCdromDevices::Scan()
 942 {
 943    bool CdromOnly = _config->FindB("APT::cdrom::CdromOnly", true);
 944    return ScanForRemovable(CdromOnly);
 945 };
 946                                                                         /*}}}*/
 947                                                                         /*{{{*/
 948 vector<CdromDevice>
 949 pkgUdevCdromDevices::ScanForRemovable(bool CdromOnly)
 950 {
 951    vector<CdromDevice> cdrom_devices;
 952    struct udev_enumerate *enumerate;
 953    struct udev_list_entry *l, *devices;
 954    struct udev *udev_ctx;
 955
 956    if(libudev_handle == NULL)
 957       return cdrom_devices;
 958
 959    udev_ctx = udev_new();
 960    enumerate = udev_enumerate_new (udev_ctx);
 961    if (CdromOnly)
 962       udev_enumerate_add_match_property(enumerate, "ID_CDROM", "1");
 963    else {
 964       udev_enumerate_add_match_sysattr(enumerate, "removable", "1");
 965    }
 966
 967    udev_enumerate_scan_devices (enumerate);
 968    devices = udev_enumerate_get_list_entry (enumerate);
 969    for (l = devices; l != NULL; l = udev_list_entry_get_next (l))
 970    {
 971       CdromDevice cdrom;
 972       struct udev_device *udevice;
 973       udevice = udev_device_new_from_syspath (udev_enumerate_get_udev (enumerate), udev_list_entry_get_name (l));
 974       if (udevice == NULL)
 975          continue;
 976       const char* devnode = udev_device_get_devnode(udevice);
 977
 978       // try fstab_dir first
 979       string mountpath;
 980       const char* mp = udev_device_get_property_value(udevice, "FSTAB_DIR");
 981       if (mp)
 982          mountpath = string(mp);
 983       else
 984          mountpath = FindMountPointForDevice(devnode);
 985
 986       // fill in the struct
 987       cdrom.DeviceName = string(devnode);
 988       if (mountpath != "") {
 989          cdrom.MountPath = mountpath;
 990          string s = string(mountpath);
 991          cdrom.Mounted = IsMounted(s);
 992       } else {
 993          cdrom.Mounted = false;
 994          cdrom.MountPath = "";
 995       }
 996       cdrom_devices.push_back(cdrom);
 997    }
 998    return cdrom_devices;
 999 }
1000                                                                         /*}}}*/
1001
1002 pkgUdevCdromDevices::~pkgUdevCdromDevices()                             /*{{{*/
1003 {
1004    if (libudev_handle != NULL)
1005       dlclose(libudev_handle);
1006 }
1007                                                                         /*}}}*/