apt-pkg/cdrom.cc

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