// -*- mode: cpp; mode: fold -*- // Description /*{{{*/ // $Id: apt-get.cc,v 1.109 2001/07/01 22:59:04 jgg Exp $ /* ###################################################################### apt-src - Cover for dpkg This is an allout cover for dpkg implementing a safer front end. It is based largely on libapt-pkg. This implements the source-based method of getting and upgrading packages. The syntax is different, apt-src [opt] command [things] Where command is: update - Update package information (same as apt-get) upgrade - Smart-Download the newest versions of all packages dist-upgrade - Powerfull upgrader designed to handle the issues with a new distribution. install - Download and install a given package (by name, not by .deb) clean - Erase the .debs downloaded to /var/cache/apt/archives and the partial dir too. ##################################################################### */ /*}}}*/ // Include Files /*{{{*/ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "acqprogress.h" #include #include #include #include #include #include #include #include #include #include #include #include /*}}}*/ using namespace std; ostream c0out(0); ostream c1out(0); ostream c2out(0); ofstream devnull("/dev/null"); unsigned int ScreenWidth = 80; // Fetch a source file to the requested directory /*{{{*/ // --------------------------------------------------------------------- class pkgAcqSrcFile : public pkgAcquire::Item { pkgAcquire::ItemDesc Desc; string Md5Hash; unsigned int Retries; public: // Specialized action members virtual void Failed(string Message,pkgAcquire::MethodConfig *Cnf); virtual void Done(string Message,unsigned long Size,string Md5Hash, pkgAcquire::MethodConfig *Cnf); virtual string MD5Sum() {return Md5Hash;}; virtual string DescURI() {return Desc.URI;}; pkgAcqSrcFile(pkgAcquire *Owner,string URI,string MD5,unsigned long Size, string Desc,string ShortDesc); }; /*}}}*/ // AcqFile::pkgAcqSrcFile - Constructor /*{{{*/ // --------------------------------------------------------------------- /* The file is added to the queue */ pkgAcqSrcFile::pkgAcqSrcFile(pkgAcquire *Owner,string URI,string MD5, unsigned long Size,string Dsc,string ShortDesc) : Item(Owner), Md5Hash(MD5) { Retries = _config->FindI("Acquire::Retries",0); // If you use the '-d' flag then you don't have to be root, // and the files are downloaded into the current directory. if (_config->FindB("APT::Get::Download-Only",false) == true) { DestFile = flNotDir(URI); } else { DestFile = _config->FindDir("Dir::Cache::Archives") + "partial/" + flNotDir(URI); } // Create the item Desc.URI = URI; Desc.Description = Dsc; Desc.Owner = this; // Set the short description to the archive component Desc.ShortDesc = ShortDesc; // Get the transfer sizes FileSize = Size; struct stat Buf; if (stat(DestFile.c_str(),&Buf) == 0) { // Hmm, the partial file is too big, erase it if ((unsigned)Buf.st_size > Size) unlink(DestFile.c_str()); else PartialSize = Buf.st_size; } QueueURI(Desc); } /*}}}*/ // AcqFile::Done - Item downloaded OK /*{{{*/ // --------------------------------------------------------------------- /* */ void pkgAcqSrcFile::Done(string Message,unsigned long Size,string MD5, pkgAcquire::MethodConfig *Cnf) { // Check the md5 if (Md5Hash.empty() == false && MD5.empty() == false) { if (Md5Hash != MD5) { Status = StatError; ErrorText = "MD5Sum mismatch"; Rename(DestFile,DestFile + ".FAILED"); return; } } Item::Done(Message,Size,MD5,Cnf); string FileName = LookupTag(Message,"Filename"); if (FileName.empty() == true) { Status = StatError; ErrorText = "Method gave a blank filename"; return; } Complete = true; // The files timestamp matches if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == true) return; // We have to copy it into place if (FileName != DestFile) { Local = true; if (_config->FindB("Acquire::Source-Symlinks",true) == false || Cnf->Removable == true) { Desc.URI = "copy:" + FileName; QueueURI(Desc); return; } // Erase the file if it is a symlink so we can overwrite it struct stat St; if (lstat(DestFile.c_str(),&St) == 0) { if (S_ISLNK(St.st_mode) != 0) unlink(DestFile.c_str()); } // Symlink the file if (symlink(FileName.c_str(),DestFile.c_str()) != 0) { ErrorText = "Link to " + DestFile + " failure "; Status = StatError; Complete = false; } } } /*}}}*/ // AcqFile::Failed - Failure handler /*{{{*/ // --------------------------------------------------------------------- /* Here we try other sources */ void pkgAcqSrcFile::Failed(string Message,pkgAcquire::MethodConfig *Cnf) { ErrorText = LookupTag(Message,"Message"); // This is the retry counter if (Retries != 0 && Cnf->LocalOnly == false && StringToBool(LookupTag(Message,"Transient-Failure"),false) == true) { Retries--; QueueURI(Desc); return; } Item::Failed(Message,Cnf); } /*}}}*/ // class CacheFile - Cover class for some dependency cache functions /*{{{*/ // --------------------------------------------------------------------- /* */ class CacheFile : public pkgCacheFile { static pkgCache *SortCache; static int NameComp(const void *a,const void *b); bool *wait; bool *source; public: pkgCache::Package **List; void Sort(); bool CheckDeps(bool AllowInstall = false); bool Open(bool WithLock = true) { OpTextProgress Prog(*_config); if (pkgCacheFile::Open(Prog,WithLock) == false) return false; Sort(); // Save extra information unsigned long Size = Cache->Head().PackageCount; wait = new bool[Size]; memset(wait,false,sizeof(*wait)*Size); source = new bool[Size]; memset(source,false,sizeof(*source)*Size); return true; }; bool OpenForInstall() { if (_config->FindB("APT::Get::Print-URIs") == true) return Open(false); else return Open(true); }; void MarkSource(pkgCache::PkgIterator const &Pkg, bool flag); void MarkWait(pkgCache::PkgIterator const &Pkg, bool flag); bool GetSource(pkgCache::PkgIterator const &Pkg); bool GetWait(pkgCache::PkgIterator const &Pkg); CacheFile() : List(0) {}; ~CacheFile() { delete [] wait; delete [] source; }; }; /*}}}*/ // ShowBroken - Debugging aide /*{{{*/ // --------------------------------------------------------------------- /* This prints out the names of all the packages that are broken along with the name of each each broken dependency and a quite version description. The output looks like: Sorry, but the following packages have unmet dependencies: exim: Depends: libc6 (>= 2.1.94) but 2.1.3-10 is to be installed Depends: libldap2 (>= 2.0.2-2) but it is not going to be installed Depends: libsasl7 but it is not going to be installed */ void ShowBroken(ostream &out,CacheFile &Cache,bool Now) { out << _("Sorry, but the following packages have unmet dependencies:") << endl; for (unsigned J = 0; J < Cache->Head().PackageCount; J++) { pkgCache::PkgIterator I(Cache,Cache.List[J]); if (Now == true) { if (Cache[I].NowBroken() == false) continue; } else { if (Cache[I].InstBroken() == false) continue; } // Print out each package and the failed dependencies out <<" " << I.Name() << ":"; unsigned Indent = strlen(I.Name()) + 3; bool First = true; pkgCache::VerIterator Ver; if (Now == true) Ver = I.CurrentVer(); else Ver = Cache[I].InstVerIter(Cache); if (Ver.end() == true) { out << endl; continue; } for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false;) { // Compute a single dependency element (glob or) pkgCache::DepIterator Start; pkgCache::DepIterator End; D.GlobOr(Start,End); if (Cache->IsImportantDep(End) == false) continue; if (Now == true) { if ((Cache[End] & pkgDepCache::DepGNow) == pkgDepCache::DepGNow) continue; } else { if ((Cache[End] & pkgDepCache::DepGInstall) == pkgDepCache::DepGInstall) continue; } bool FirstOr = true; while (1) { if (First == false) for (unsigned J = 0; J != Indent; J++) out << ' '; First = false; if (FirstOr == false) { for (unsigned J = 0; J != strlen(End.DepType()) + 3; J++) out << ' '; } else out << ' ' << End.DepType() << ": "; FirstOr = false; out << Start.TargetPkg().Name(); // Show a quick summary of the version requirements if (Start.TargetVer() != 0) out << " (" << Start.CompType() << " " << Start.TargetVer() << ")"; /* Show a summary of the target package if possible. In the case of virtual packages we show nothing */ pkgCache::PkgIterator Targ = Start.TargetPkg(); if (Targ->ProvidesList == 0) { out << ' '; pkgCache::VerIterator Ver = Cache[Targ].InstVerIter(Cache); if (Now == true) Ver = Targ.CurrentVer(); if (Ver.end() == false) { if (Now == true) ioprintf(out,_("but %s is installed"),Ver.VerStr()); else ioprintf(out,_("but %s is to be installed"),Ver.VerStr()); } else { if (Cache[Targ].CandidateVerIter(Cache).end() == true) { if (Targ->ProvidesList == 0) out << _("but it is not installable"); else out << _("but it is a virtual package"); } else out << (Now?_("but it is not installed"):_("but it is not going to be installed")); } } if (Start != End) out << _(" or"); out << endl; if (Start == End) break; Start++; } } } } /*}}}*/ // CacheFile::NameComp - QSort compare by name /*{{{*/ // --------------------------------------------------------------------- /* */ pkgCache *CacheFile::SortCache = 0; int CacheFile::NameComp(const void *a,const void *b) { if (*(pkgCache::Package **)a == 0 || *(pkgCache::Package **)b == 0) return *(pkgCache::Package **)a - *(pkgCache::Package **)b; const pkgCache::Package &A = **(pkgCache::Package **)a; const pkgCache::Package &B = **(pkgCache::Package **)b; return strcmp(SortCache->StrP + A.Name,SortCache->StrP + B.Name); } /*}}}*/ // CacheFile::Sort - Sort by name /*{{{*/ // --------------------------------------------------------------------- /* */ void CacheFile::Sort() { delete [] List; List = new pkgCache::Package *[Cache->Head().PackageCount]; memset(List,0,sizeof(*List)*Cache->Head().PackageCount); pkgCache::PkgIterator I = Cache->PkgBegin(); for (;I.end() != true; I++) List[I->ID] = I; SortCache = *this; qsort(List,Cache->Head().PackageCount,sizeof(*List),NameComp); } /*}}}*/ // CacheFile::CheckDeps - Open the cache file /*{{{*/ // --------------------------------------------------------------------- /* This routine generates the caches and then opens the dependency cache and verifies that the system is OK. */ bool CacheFile::CheckDeps(bool AllowInstall = false) { if (_error->PendingError() == true) return false; // Check that the system is OK if (!AllowInstall && (DCache->DelCount() != 0 || DCache->InstCount() != 0)) return _error->Error("Internal Error, non-zero counts"); // Apply corrections for half-installed packages if (pkgApplyStatus(*DCache) == false) return false; // Nothing is broken if (DCache->BrokenCount() == 0) return true; // Attempt to fix broken things if (_config->FindB("APT::Get::Fix-Broken",false) == true) { c1out << _("Correcting dependencies...") << flush; if (pkgFixBroken(*DCache) == false || DCache->BrokenCount() != 0) { c1out << _(" failed.") << endl; ShowBroken(c1out,*this,true); return _error->Error(_("Unable to correct dependencies")); } if (pkgMinimizeUpgrade(*DCache) == false) return _error->Error(_("Unable to minimize the upgrade set")); c1out << _(" Done") << endl; } else { c1out << _("You might want to run `apt-get -f install' to correct these.") << endl; ShowBroken(c1out,*this,true); return _error->Error(_("Unmet dependencies. Try using -f.")); } return true; } /*}}}*/ // CacheFile::MarkSource - We want to download the source /*{{{*/ // --------------------------------------------------------------------- /* */ void CacheFile::MarkSource(pkgCache::PkgIterator const &Pkg, bool flag) { // Simplifies other routines. if (Pkg.end() == true) return; // Mark it. source[Pkg->ID] = flag; } /*}}}*/ // CacheFile::MarkWait - We need to install this source later /*{{{*/ // --------------------------------------------------------------------- /* */ void CacheFile::MarkWait(pkgCache::PkgIterator const &Pkg, bool flag) { // Simplifies other routines. if (Pkg.end() == true) return; wait[Pkg->ID] = flag; } /*}}}*/ // CacheFile::GetSource - Test Source flag /*{{{*/ // --------------------------------------------------------------------- /* */ bool CacheFile::GetSource(pkgCache::PkgIterator const &Pkg) { return source[Pkg->ID]; } /*}}}*/ // CacheFile::GetWait - Test Wait flag /*{{{*/ // --------------------------------------------------------------------- /* */ bool CacheFile::GetWait(pkgCache::PkgIterator const &Pkg) { return wait[Pkg->ID]; } /*}}}*/ // ForceInstall - Forcably install / reinstall a package /*{{{*/ // --------------------------------------------------------------------- /* */ static void ForceInstall(pkgDepCache &Cache,pkgCache::PkgIterator const &Pkg) { pkgDepCache::StateCache &State = Cache[Pkg]; // Install it Cache.MarkInstall(Pkg,false); if (State.Install() == false) { if (Pkg->CurrentVer != 0) { Cache.SetReInstall(Pkg,true); } } } /*}}}*/ // YnPrompt - Yes No Prompt. /*{{{*/ // --------------------------------------------------------------------- /* Returns true on a Yes.*/ static bool YnPrompt() { // This needs to be a capital const char *Yes = _("Y"); if (_config->FindB("APT::Get::Assume-Yes",false) == true) { c1out << Yes << endl; return true; } char C = 0; char Jnk = 0; if (read(STDIN_FILENO,&C,1) != 1) return false; while (C != '\n' && Jnk != '\n') if (read(STDIN_FILENO,&Jnk,1) != 1) return false; if (!(toupper(C) == *Yes || C == '\n' || C == '\r')) return false; return true; } /*}}}*/ // AnalPrompt - Annoying Yes No Prompt. /*{{{*/ // --------------------------------------------------------------------- /* Returns true on a Yes.*/ static bool AnalPrompt(const char *Text) { char Buf[1024]; cin.getline(Buf,sizeof(Buf)); if (strcmp(Buf,Text) == 0) return true; return false; } /*}}}*/ // ShowList - Show a list /*{{{*/ // --------------------------------------------------------------------- /* This prints out a string of space separated words with a title and a two space indent line wraped to the current screen width. */ static bool ShowList(ostream &out,string Title,string List) { if (List.empty() == true) return true; // Acount for the leading space int ScreenWidth = ::ScreenWidth - 3; out << Title << endl; string::size_type Start = 0; while (Start < List.size()) { string::size_type End; if (Start + ScreenWidth >= List.size()) End = List.size(); else End = List.rfind(' ',Start+ScreenWidth); if (End == string::npos || End < Start) End = Start + ScreenWidth; out << " " << string(List,Start,End - Start) << endl; Start = End + 1; } return false; } /*}}}*/ // ShowNew - Show packages to newly install /*{{{*/ // --------------------------------------------------------------------- /* */ static void ShowNew(ostream &out,CacheFile &Cache) { /* Print out a list of packages that are going to be removed extra to what the user asked */ string List; for (unsigned J = 0; J < Cache->Head().PackageCount; J++) { pkgCache::PkgIterator I(Cache,Cache.List[J]); if (Cache[I].NewInstall() == true) List += string(I.Name()) + " "; } ShowList(out,_("The following NEW packages will be installed:"),List); } /*}}}*/ // ShowDel - Show packages to delete /*{{{*/ // --------------------------------------------------------------------- /* */ static void ShowDel(ostream &out,CacheFile &Cache) { /* Print out a list of packages that are going to be removed extra to what the user asked */ string List; for (unsigned J = 0; J < Cache->Head().PackageCount; J++) { pkgCache::PkgIterator I(Cache,Cache.List[J]); if (Cache[I].Delete() == true) { if ((Cache[I].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge) List += string(I.Name()) + "* "; else List += string(I.Name()) + " "; } } ShowList(out,_("The following packages will be REMOVED:"),List); } /*}}}*/ // ShowKept - Show kept packages /*{{{*/ // --------------------------------------------------------------------- /* */ static void ShowKept(ostream &out,CacheFile &Cache) { string List; for (unsigned J = 0; J < Cache->Head().PackageCount; J++) { pkgCache::PkgIterator I(Cache,Cache.List[J]); // Not interesting if (Cache[I].Upgrade() == true || Cache[I].Upgradable() == false || I->CurrentVer == 0 || Cache[I].Delete() == true) continue; List += string(I.Name()) + " "; } ShowList(out,_("The following packages have been kept back"),List); } /*}}}*/ // ShowUpgraded - Show upgraded packages /*{{{*/ // --------------------------------------------------------------------- /* */ static void ShowUpgraded(ostream &out,CacheFile &Cache) { string List; for (unsigned J = 0; J < Cache->Head().PackageCount; J++) { pkgCache::PkgIterator I(Cache,Cache.List[J]); // Not interesting if (Cache[I].Upgrade() == false || Cache[I].NewInstall() == true) continue; List += string(I.Name()) + " "; } ShowList(out,_("The following packages will be upgraded"),List); } /*}}}*/ // ShowDowngraded - Show downgraded packages /*{{{*/ // --------------------------------------------------------------------- /* */ static bool ShowDowngraded(ostream &out,CacheFile &Cache) { string List; for (unsigned J = 0; J < Cache->Head().PackageCount; J++) { pkgCache::PkgIterator I(Cache,Cache.List[J]); // Not interesting if (Cache[I].Downgrade() == false || Cache[I].NewInstall() == true) continue; List += string(I.Name()) + " "; } return ShowList(out,_("The following packages will be DOWNGRADED"),List); } /*}}}*/ // ShowHold - Show held but changed packages /*{{{*/ // --------------------------------------------------------------------- /* */ static bool ShowHold(ostream &out,CacheFile &Cache) { string List; for (unsigned J = 0; J < Cache->Head().PackageCount; J++) { pkgCache::PkgIterator I(Cache,Cache.List[J]); if (Cache[I].InstallVer != (pkgCache::Version *)I.CurrentVer() && I->SelectedState == pkgCache::State::Hold) List += string(I.Name()) + " "; } return ShowList(out,_("The following held packages will be changed:"),List); } /*}}}*/ // ShowEssential - Show an essential package warning /*{{{*/ // --------------------------------------------------------------------- /* This prints out a warning message that is not to be ignored. It shows all essential packages and their dependents that are to be removed. It is insanely risky to remove the dependents of an essential package! */ static bool ShowEssential(ostream &out,CacheFile &Cache) { string List; bool *Added = new bool[Cache->Head().PackageCount]; for (unsigned int I = 0; I != Cache->Head().PackageCount; I++) Added[I] = false; for (unsigned J = 0; J < Cache->Head().PackageCount; J++) { pkgCache::PkgIterator I(Cache,Cache.List[J]); if ((I->Flags & pkgCache::Flag::Essential) != pkgCache::Flag::Essential && (I->Flags & pkgCache::Flag::Important) != pkgCache::Flag::Important) continue; // The essential package is being removed if (Cache[I].Delete() == true) { if (Added[I->ID] == false) { Added[I->ID] = true; List += string(I.Name()) + " "; } } if (I->CurrentVer == 0) continue; // Print out any essential package depenendents that are to be removed for (pkgCache::DepIterator D = I.CurrentVer().DependsList(); D.end() == false; D++) { // Skip everything but depends if (D->Type != pkgCache::Dep::PreDepends && D->Type != pkgCache::Dep::Depends) continue; pkgCache::PkgIterator P = D.SmartTargetPkg(); if (Cache[P].Delete() == true) { if (Added[P->ID] == true) continue; Added[P->ID] = true; char S[300]; snprintf(S,sizeof(S),_("%s (due to %s) "),P.Name(),I.Name()); List += S; } } } delete [] Added; return ShowList(out,_("WARNING: The following essential packages will be removed\n" "This should NOT be done unless you know exactly what you are doing!"),List); } /*}}}*/ // Stats - Show some statistics /*{{{*/ // --------------------------------------------------------------------- /* */ static void Stats(ostream &out,pkgDepCache &Dep) { unsigned long Upgrade = 0; unsigned long Downgrade = 0; unsigned long Install = 0; unsigned long ReInstall = 0; for (pkgCache::PkgIterator I = Dep.PkgBegin(); I.end() == false; I++) { if (Dep[I].NewInstall() == true) Install++; else { if (Dep[I].Upgrade() == true) Upgrade++; else if (Dep[I].Downgrade() == true) Downgrade++; } if (Dep[I].Delete() == false && (Dep[I].iFlags & pkgDepCache::ReInstall) == pkgDepCache::ReInstall) ReInstall++; } ioprintf(out,_("%lu packages upgraded, %lu newly installed, "), Upgrade,Install); if (ReInstall != 0) ioprintf(out,_("%lu reinstalled, "),ReInstall); if (Downgrade != 0) ioprintf(out,_("%lu downgraded, "),Downgrade); ioprintf(out,_("%lu to remove and %lu not upgraded.\n"), Dep.DelCount(),Dep.KeepCount()); if (Dep.BadCount() != 0) ioprintf(out,_("%lu packages not fully installed or removed.\n"), Dep.BadCount()); } /*}}}*/ // FindSrc - Find a source record /*{{{*/ // --------------------------------------------------------------------- /* */ pkgSrcRecords::Parser *FindSrc(const char *Name,pkgRecords &Recs, pkgSrcRecords &SrcRecs,string &Src, pkgDepCache &Cache) { // We want to pull the version off the package specification.. string VerTag; string TmpSrc = Name; string::size_type Slash = TmpSrc.rfind('='); if (Slash != string::npos) { VerTag = string(TmpSrc.begin() + Slash + 1,TmpSrc.end()); TmpSrc = string(TmpSrc.begin(),TmpSrc.begin() + Slash); } if (_error->PendingError() == true) { _error->DumpErrors(); ioprintf(cout, "Findsrc: Pending Error!\n"); return 0; } /* Lookup the version of the package we would install if we were to install a version and determine the source package name, then look in the archive for a source package of the same name. In theory we could stash the version string as well and match that too but today there aren't multi source versions in the archive. */ if (_config->FindB("APT::Get::Only-Source") == false && VerTag.empty() == true) { pkgCache::PkgIterator Pkg = Cache.FindPkg(TmpSrc); if (Pkg.end() == false) { pkgCache::VerIterator Ver = Cache.GetCandidateVer(Pkg); if (Ver.end() == false) { pkgRecords::Parser &Parse = Recs.Lookup(Ver.FileList()); Src = Parse.SourcePkg(); } } } // No source package name.. if (Src.empty() == true) Src = TmpSrc; // The best hit pkgSrcRecords::Parser *Last = 0; unsigned long Offset = 0; string Version; bool IsMatch = false; // If we are matching by version then we need exact matches to be happy if (VerTag.empty() == false) IsMatch = true; /* Iterate over all of the hits, which includes the resulting binary packages in the search */ pkgSrcRecords::Parser *Parse; SrcRecs.Restart(); while ((Parse = SrcRecs.Find(Src.c_str(),false)) != 0) { string Ver = Parse->Version(); // Skip name mismatches if (IsMatch == true && Parse->Package() != Src) continue; //ioprintf(cout, "Looking in FindSrc at %s\n", Parse->Package().c_str()); if (VerTag.empty() == false) { /* Don't want to fall through because we are doing exact version matching. */ if (Cache.VS().CmpVersion(VerTag,Ver) != 0) continue; Last = Parse; Offset = Parse->Offset(); break; } // Newer version or an exact match if (Last == 0 || Cache.VS().CmpVersion(Version,Ver) < 0 || (Parse->Package() == Src && IsMatch == false)) { IsMatch = Parse->Package() == Src; Last = Parse; Offset = Parse->Offset(); Version = Ver; } } if (Last == 0) { ioprintf(cout, "Findsrc: No match for %s! (Package: %s)\n", Src.c_str(), Name); return 0; } if (Last->Jump(Offset) == false) return 0; return Last; } /*}}}*/ // DoUpdate - Update the package lists /*{{{*/ // --------------------------------------------------------------------- /* */ static bool DoUpdate(CommandLine &CmdL) { if (CmdL.FileSize() != 1) return _error->Error(_("The update command takes no arguments")); // Get the source list pkgSourceList List; if (List.ReadMainList() == false) return false; // Lock the list directory FileFd Lock; if (_config->FindB("Debug::NoLocking",false) == false) { Lock.Fd(GetLock(_config->FindDir("Dir::State::Lists") + "lock")); if (_error->PendingError() == true) return _error->Error(_("Unable to lock the list directory")); } // Create the download object AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0)); pkgAcquire Fetcher(&Stat); // Populate it with the source selection if (List.GetIndexes(&Fetcher) == false) return false; // Run it if (Fetcher.Run() == pkgAcquire::Failed) return false; bool Failed = false; for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); I++) { if ((*I)->Status == pkgAcquire::Item::StatDone) continue; (*I)->Finished(); fprintf(stderr,_("Failed to fetch %s %s\n"),(*I)->DescURI().c_str(), (*I)->ErrorText.c_str()); Failed = true; } // Clean out any old list files if (_config->FindB("APT::Get::List-Cleanup",true) == true) { if (Fetcher.Clean(_config->FindDir("Dir::State::lists")) == false || Fetcher.Clean(_config->FindDir("Dir::State::lists") + "partial/") == false) return false; } // Prepare the cache. CacheFile Cache; if (Cache.Open() == false) return false; if (Failed == true) return _error->Error(_("Some index files failed to download, they have been ignored, or old ones used instead.")); return true; } /*}}}*/ // DoClean - Remove download archives /*{{{*/ // --------------------------------------------------------------------- /* */ static bool DoClean(CommandLine &CmdL) { if (_config->FindB("APT::Get::Simulate") == true) { cout << "Del " << _config->FindDir("Dir::Cache::archives") << "* " << _config->FindDir("Dir::Cache::archives") << "partial/*" << endl; return true; } // Lock the archive directory FileFd Lock; if (_config->FindB("Debug::NoLocking",false) == false) { Lock.Fd(GetLock(_config->FindDir("Dir::Cache::Archives") + "lock")); if (_error->PendingError() == true) return _error->Error(_("Unable to lock the download directory")); } pkgAcquire Fetcher; Fetcher.Clean(_config->FindDir("Dir::Cache::archives")); Fetcher.Clean(_config->FindDir("Dir::Cache::archives") + "partial/"); return true; } /*}}}*/ // DoCheck - Perform the check operation /*{{{*/ // --------------------------------------------------------------------- /* Opening automatically checks the system, this command is mostly used for debugging */ static bool DoCheck(CommandLine &CmdL) { CacheFile Cache; Cache.Open(); Cache.CheckDeps(); return true; } /*}}}*/ // GetSource - Fetch a source archive /*{{{*/ // --------------------------------------------------------------------- /* Fetch souce packages */ struct DscFile { string Package; string Version; string Dsc; }; static bool GetSource(CacheFile &Cache, pkgRecords &Recs, pkgSrcRecords &SrcRecs, bool Ask = true) { bool Fail = false; bool Essential = false; // Show all the various warning indicators ShowDel(c1out,Cache); ShowNew(c1out,Cache); Fail |= !ShowHold(c1out,Cache); if (_config->FindB("APT::Get::Show-Upgraded",false) == true) ShowUpgraded(c1out,Cache); Fail |= !ShowDowngraded(c1out,Cache); Essential = !ShowEssential(c1out,Cache); Fail |= Essential; Stats(c1out,Cache); // Sanity check if (Cache->BrokenCount() != 0) { ShowBroken(c1out,Cache,false); return _error->Error("Internal Error, GetSource was called with broken packages!"); } if (Cache->DelCount() == 0 && Cache->InstCount() == 0 && Cache->BadCount() == 0) return true; // Create the download object AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0)); pkgAcquire Fetcher(&Stat); unsigned J = 0; for (unsigned I = 0; I < Cache->Head().PackageCount; I++) { pkgCache::PkgIterator pkg(Cache,Cache.List[I]); // Only installable packages if (Cache[pkg].Install() == true || Cache.GetSource(pkg) == true) J++; } DscFile *Dsc = new DscFile[J]; string *SrcNames = new string[J]; J = 0; string List; for (unsigned I = 0; I < Cache->Head().PackageCount; I++) { pkgCache::PkgIterator pkg(Cache,Cache.List[I]); // Only packages we have marked as source downloads if (Cache.GetSource(pkg) == false) continue; // Load the requested source into the fetcher string Src; pkgSrcRecords::Parser *Last = FindSrc(pkg.Name(),Recs,SrcRecs,Src,Cache); if (Last == 0) { ioprintf(c1out,_("Unable to find a source package for %s\n"),pkg.Name()); continue; } bool skip = false; // Hack - do not download multiple packages from the same source for (int K = 0; K < J; K++) { if (Src == SrcNames[K]) { skip = true; break; } } // Skip this package if we are already getting the source if (skip == true) continue; // Save the name SrcNames[J] = Src; // Back track vector Lst; if (Last->Files(Lst) == false) continue; // Load them into the fetcher for (vector::const_iterator I = Lst.begin(); I != Lst.end(); I++) { // Try to guess what sort of file it is we are getting. if (I->Type == "dsc") { Dsc[J].Package = Last->Package(); Dsc[J].Version = Last->Version(); Dsc[J].Dsc = flNotDir(I->Path); } // Diff only mode only fetches .diff files if (_config->FindB("APT::Get::Diff-Only",false) == true && I->Type != "diff") continue; // Tar only mode only fetches .tar files if (_config->FindB("APT::Get::Tar-Only",false) == true && I->Type != "tar") continue; new pkgAcqSrcFile(&Fetcher,Last->Index().ArchiveURI(I->Path), I->MD5Hash,I->Size, Last->Index().SourceInfo(*Last,*I),Src); } J++; } // Display statistics double FetchBytes = Fetcher.FetchNeeded(); double FetchPBytes = Fetcher.PartialPresent(); double DebBytes = Fetcher.TotalNeeded(); // Check for enough free space struct statvfs Buf; string OutputDir = "."; if (statvfs(OutputDir.c_str(),&Buf) != 0) return _error->Errno("statvfs","Couldn't determine free space in %s", OutputDir.c_str()); // (This should probably be modified to include effects of .o files) if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize) return _error->Error(_("Sorry, you don't have enough free space in %s"), OutputDir.c_str()); if (_config->FindB("APT::Get::Simulate",false) == true) { for (unsigned I = 0; I != J; I++) ioprintf(cout,_("Fetch Source %s\n"),Dsc[I].Package.c_str()); return true; } if (Essential == true) { if (_config->FindB("APT::Get::Trivial-Only",false) == true) return _error->Error(_("Trivial Only specified but this is not a trivial operation.")); const char *Prompt = _("Yes, do as I say!"); ioprintf(c2out, _("You are about to do something potentially harmful\n" "To continue type in the phrase '%s'\n" " ?] "),Prompt); c2out << flush; if (AnalPrompt(Prompt) == false) { c2out << _("Abort.") << endl; exit(1); } } else { // Prompt to continue if (Ask == true || Fail == true) { if (_config->FindB("APT::Get::Trivial-Only",false) == true) return _error->Error(_("Trivial Only specified but this is not a trivial operation.")); if (_config->FindI("quiet",0) < 2 && _config->FindB("APT::Get::Assume-Yes",false) == false) { c2out << _("Do you want to continue? [Y/n] ") << flush; if (YnPrompt() == false) { c2out << _("Abort.") << endl; exit(1); } } } } // Just print out the uris an exit if the --print-uris flag was used if (_config->FindB("APT::Get::Print-URIs") == true) { pkgAcquire::UriIterator I = Fetcher.UriBegin(); for (; I != Fetcher.UriEnd(); I++) cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' << I->Owner->FileSize << ' ' << I->Owner->MD5Sum() << endl; return true; } // Run it if (Fetcher.Run() == pkgAcquire::Failed) return false; // Print error messages bool Failed = false; for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); I++) { if ((*I)->Status == pkgAcquire::Item::StatDone && (*I)->Complete == true) continue; fprintf(stderr,_("Failed to fetch %s %s\n"),(*I)->DescURI().c_str(), (*I)->ErrorText.c_str()); Failed = true; } if (Failed == true) return _error->Error(_("Failed to fetch some archives.")); if (_config->FindB("APT::Get::Download-only",false) == true) { c1out << _("Download complete and in download only mode") << endl; return true; } // Unpack the sources pid_t Process = ExecFork(); if (Process == 0) { for (unsigned I = 0; I != J; I++) { string Dir = Dsc[I].Package + '-' + Cache->VS().UpstreamVersion(Dsc[I].Version.c_str()); Dir = _config->FindDir("Dir::Cache::Archives") + "partial/" + Dir; // Diff only mode only fetches .diff files if (_config->FindB("APT::Get::Diff-Only",false) == true || _config->FindB("APT::Get::Tar-Only",false) == true || Dsc[I].Dsc.empty() == true) continue; // See if the package is already unpacked struct stat Stat; if (stat(Dir.c_str(),&Stat) == 0 && S_ISDIR(Stat.st_mode) != 0) { ioprintf(c0out ,_("Skipping unpack of already unpacked source in %s\n"), Dir.c_str()); } else { // Call dpkg-source char S[500]; snprintf(S,sizeof(S),"cd %spartial/ && %s -x %s", _config->FindDir("Dir::Cache::Archives").c_str(), _config->Find("Dir::Bin::dpkg-source","dpkg-source").c_str(), Dsc[I].Dsc.c_str()); if (system(S) != 0) { fprintf(stderr,_("Unpack command '%s' failed.\n"),S); _exit(1); } } } _exit(0); } // Wait for the subprocess int Status = 0; while (waitpid(Process,&Status,0) != Process) { if (errno == EINTR) continue; return _error->Errno("waitpid","Couldn't wait for subprocess"); } if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0) return _error->Error(_("Child process failed")); return true; } /*}}}*/ // CompileSource - Compile list of new source packages /*{{{*/ // --------------------------------------------------------------------- static bool CompileSource(CacheFile &Cache, pkgRecords &Recs, pkgSrcRecords &SrcRecs, bool distupgrade = false) { unsigned ExpectedInst; pkgProblemResolver Fix(Cache); // Clear protect flag for (unsigned J = 0; J < Cache->Head().PackageCount; J++) { pkgCache::PkgIterator Pkg(Cache,Cache.List[J]); Fix.Clear(Pkg); } bool compiled_something; // Don't do anything if told not to if (_config->FindB("APT::Get::Download-only",false) == true) { return true; } if (_error->PendingError() == true) return false; // Lock the archive directory FileFd Lock; if (_config->FindB("Debug::NoLocking",false) == false) { Lock.Fd(GetLock(_config->FindDir("Dir::Cache::Archives") + "lock")); if (_error->PendingError() == true) return _error->Error(_("Unable to lock the download directory")); } /* * Repeatly do the following: * 1) Compile all packages compilable. * 2) Install all marked packages we have compiled that are installable. * * If either step doesn't do anything, then we are stuck, so stop. */ while (true) { compiled_something = false; // Install pending packages. SPtr PM= _system->CreatePM(Cache); // Try to compile the packages. for (unsigned J = 0; J < Cache->Head().PackageCount; J++) { pkgCache::PkgIterator Pkg(Cache,Cache.List[J]); // Only look at things we haven't compiled yet if (Cache.GetSource(Pkg) == false) continue; // This is a pure virtual package and there is a single available provides if (Cache[Pkg].CandidateVer == 0 && Pkg->ProvidesList != 0 && Pkg.ProvidesList()->NextProvides == 0) { pkgCache::PkgIterator Tmp = Pkg.ProvidesList().OwnerPkg(); Pkg = Tmp; } string Src; pkgSrcRecords::Parser *Last = FindSrc(Pkg.Name(),Recs,SrcRecs,Src,Cache); if (Last == 0) return false; // We can now compile it string Dir = Last->Package() + '-' + Cache->VS().UpstreamVersion(Last->Version().c_str()); // Call dpkg-buildpackage char S[500]; snprintf(S,sizeof(S),"cd %spartial/%s && %s %s", _config->FindDir("Dir::Cache::Archives").c_str(), Dir.c_str(), _config->Find("Dir::Bin::dpkg-buildpackage","dpkg-buildpackage").c_str(), _config->Find("DPkg::Build-Options","-b -uc -nc -D").c_str()); // Notice the packages. if (system(S) == 0) { // We have now compiled a file in this round compiled_something = true; string StartDir = SafeGetCWD(); string dir = _config->FindDir("Dir::Cache::Archives") + _("partial"); string archive = _config->FindDir("Dir::Cache::Archives"); DIR *D = opendir(dir.c_str()); chdir(Dir.c_str()); for (struct dirent *Dirent = readdir(D); Dirent != 0; Dirent = readdir(D)) { string fname = Dirent->d_name; string Filename = dir + "/" + fname; // Hack - we assume the packages are .deb's for now. if (flExtension(fname) != _("deb")) continue; string::size_type len = 0; pkgCache::PkgIterator PkgFnd = Cache->PkgBegin(); for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() == false; I++) { string pkgname = ((string) I.Name()) + "_"; // We want the package with the largest matching name if (pkgname.length() < len) continue; // Is the package name a prefix to the file name? if (fname.find(pkgname) == 0) { len = pkgname.length(); PkgFnd = I; } } ioprintf(cout, "Found Package: %s for %s\n", PkgFnd.Name(), Filename.c_str()); string destfile = _config->FindDir("Dir::Cache::Archives") + fname; // Move file... rename(Filename.c_str(),destfile.c_str()); // Remember filename PM->SaveFilename(PkgFnd, destfile); // Do we want to install this package? if (Cache.GetSource(PkgFnd) == false) continue; // Mark no longer need source Cache.MarkSource(PkgFnd,false); // Add to the 'wait' list Cache.MarkWait(PkgFnd,true); }; // Move back to original directory chdir(StartDir.c_str()); closedir(D); // Remove the directory snprintf(S,sizeof(S),"cd %spartial && rm -rf %s ", _config->FindDir("Dir::Cache::Archives").c_str(), Dir.c_str()); system(S); } } // break out if we did nothing if (!compiled_something) break; // Recalculate dependancies Cache.CheckDeps(true); pkgProblemResolver Fix(Cache); // Add the waiting packages to the install list for (unsigned J = 0; J < Cache->Head().PackageCount; J++) { pkgCache::PkgIterator Pkg(Cache,Cache.List[J]); // Is this package waiting to be installed? if (Cache.GetWait(Pkg) == true) { ForceInstall(Cache, Pkg); Fix.Protect(Pkg); } else { Cache->MarkKeep(Pkg); } } if (distupgrade) { if (Fix.Resolve() == false) _error->Discard(); } else { if (Fix.ResolveByKeep() == false) _error->Discard(); } bool installing = false; // Do we have anything to install? for (unsigned J = 0; J < Cache->Head().PackageCount; J++) { pkgCache::PkgIterator Pkg(Cache,Cache.List[J]); if (Cache[Pkg].Install() || (Cache[Pkg].iFlags & pkgDepCache::ReInstall)) { // We are about to install it - forget the 'wait' flag Cache.MarkWait(Pkg,false); // We have something to install installing = true; Fix.Protect(Pkg); ioprintf(cout,_("Want to install %s\n"),Pkg.Name()); } if (Cache[Pkg].Delete()) { installing = true; ioprintf(cout,_("Want to remove %s\n"),Pkg.Name()); Cache.MarkWait(Pkg,false); Fix.Protect(Pkg); } } // Install and remove packages while (installing) { _system->UnLock(); pkgPackageManager::OrderResult Res = PM->DoInstall(); if (Res == pkgPackageManager::Failed || _error->PendingError() == true) { return false; } _system->Lock(); if (Res == pkgPackageManager::Completed) break; } // Done? if (!installing) break; } // Scan for uncompiled packages and complain for (unsigned J = 0; J < Cache->Head().PackageCount; J++) { pkgCache::PkgIterator Pkg(Cache,Cache.List[J]); if (Cache.GetWait(Pkg)) { _error->Error(_("Want to install %s but cannot."),Pkg.Name()); } if (Cache.GetSource(Pkg)) { _error->Error(_("Want to compile %s but cannot."),Pkg.Name()); } } // Pending errors? if (_error->PendingError()) return false; // Clean download directory char S[500]; snprintf(S,sizeof(S),"cd %spartial && rm -f *", _config->FindDir("Dir::Cache::Archives").c_str()); system(S); return true; } /*}}}*/ // DoSource - Fetch a source archive /*{{{*/ // --------------------------------------------------------------------- /* Fetch source packages */ static bool DoSource(CommandLine &CmdL) { CacheFile Cache; if (Cache.Open(false) == false) return false; if (CmdL.FileSize() <= 1) return _error->Error(_("Must specify at least one package to fetch source for")); // Read the source list pkgSourceList List; if (List.ReadMainList() == false) return _error->Error(_("The list of sources could not be read.")); // Create the text record parsers pkgRecords Recs(Cache); pkgSrcRecords SrcRecs(List); if (_error->PendingError() == true) return false; unsigned ExpectedInst; pkgProblemResolver Fix(Cache); // Find the wanted packages. for (unsigned J = 0; J < Cache->Head().PackageCount; J++) { pkgCache::PkgIterator I(Cache,Cache.List[J]); if (Cache[I].Install() == true) Fix.Protect(I); const char **J; for (J = CmdL.FileList + 1; *J != 0; J++) { if (strcmp(*J,I.Name()) == 0) { // Mark the package Cache.MarkSource(I,true); Cache->MarkInstall(I,false); break; } } } Fix.InstallProtect(); // Call the scored problem resolver Fix.Resolve(); // Sanity check if (Cache->BrokenCount() != 0) { ShowBroken(c1out,Cache,false); return _error->Error("Internal Error, InstallPackages was called with broken packages!"); } // Actually get the source files GetSource(Cache, Recs, SrcRecs); // Do not compile them... return true; } /*}}}*/ // HasBuildDeps - Can package be compiled? /*{{{*/ // --------------------------------------------------------------------- static bool HasBuildDeps(pkgCache::PkgIterator &Pkg,CacheFile &Cache, pkgRecords &Recs, pkgSrcRecords &SrcRecs) { /* This is a pure virtual package and there is a single available provides */ if (Cache[Pkg].CandidateVer == 0 && Pkg->ProvidesList != 0 && Pkg.ProvidesList()->NextProvides == 0) { pkgCache::PkgIterator Tmp = Pkg.ProvidesList().OwnerPkg(); Pkg = Tmp; } // Check if there is something at all to install pkgDepCache::StateCache &State = Cache[Pkg]; // Are we a virtual package? if (State.CandidateVer == 0) { if (Pkg->ProvidesList != 0) { // Is one of the options installed? pkgCache::PrvIterator I = Pkg.ProvidesList(); for (; I.end() == false; I++) { pkgCache::PkgIterator pkg = I.OwnerPkg(); if (pkg->CurrentVer != 0) { // Don't try to compile a virtual package. Cache.MarkSource(Pkg, false); return true; } } } return false; } string Src; pkgSrcRecords::Parser *Last = FindSrc(Pkg.Name(),Recs,SrcRecs,Src,Cache); // No source package? if (Last == 0) { return false; } // Process the build-dependencies vector BuildDeps; // No build deps - assume we can make it... if (Last->BuildDepends(BuildDeps) == false) return true; if (BuildDeps.size() == 0) return true; // Test the build-dependancies vector ::iterator D; for (D = BuildDeps.begin(); D != BuildDeps.end(); D++) { pkgCache::PkgIterator Pkg2 = Cache->FindPkg((*D).Package); // Cannot find package? if (Pkg2.end() == true) { return false; } pkgCache::VerIterator IV = Cache[Pkg2].InstVerIter(Cache); if ((*D).Type == pkgSrcRecords::Parser::BuildConflict || (*D).Type == pkgSrcRecords::Parser::BuildConflictIndep) { /* * conflict; need to remove if we have an installed version * that satisfies the version criterial */ if (IV.end() == false && Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true) { return false; } } else { /* * If this is a virtual package, we need to check the list of * packages that provide it and see if any of those are * installed */ pkgCache::PrvIterator Prv = Pkg2.ProvidesList(); for (; Prv.end() != true; Prv++) { pkgCache::PkgIterator pkg = Prv.OwnerPkg(); if (pkg->CurrentVer != 0) break; } if (Prv.end() == true) { /* * Depending on the wrong version is bad... */ if (IV.end() == true || Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == false) { // We cannot directly install return false; } } } } // Can install it return true; } /*}}}*/ // TryToInstallDeps - Try to install a single package and all its build-deps /*{{{*/ // --------------------------------------------------------------------- static bool TryToInstallDeps(pkgCache::PkgIterator &Pkg,CacheFile &Cache, pkgProblemResolver &Fix,bool Remove, bool force, unsigned int &ExpectedInst, pkgRecords &Recs, pkgSrcRecords &SrcRecs, bool InstRem = false, bool warning = true, int recursion = 0) { // Do not recurse too deeply if (recursion > 10) { ioprintf(c1out,_("Recursion limit reached.\n")); return false; } /* This is a pure virtual package and there is a single available provides */ if (Cache[Pkg].CandidateVer == 0 && Pkg->ProvidesList != 0 && Pkg.ProvidesList()->NextProvides == 0) { pkgCache::PkgIterator Tmp = Pkg.ProvidesList().OwnerPkg(); ioprintf(c1out,_("Note, selecting %s instead of %s\n"), Tmp.Name(),Pkg.Name()); Pkg = Tmp; } // Handle the no-upgrade case if (_config->FindB("APT::Get::upgrade",true) == false && Pkg->CurrentVer != 0 && force == false) { ioprintf(c1out,_("Skipping %s, it is already installed and upgrade is not set.\n"), Pkg.Name()); return true; } // Check if there is something at all to install if (Remove == true && Pkg->CurrentVer == 0) { ioprintf(c1out,_("Package %s is not installed, so not removed\n"),Pkg.Name()); return true; } pkgDepCache::StateCache &State = Cache[Pkg]; // Don't install held packages if (Pkg->SelectedState == pkgCache::State::Hold) { ioprintf(c1out,_("Bailing out: Package %s is Held\n"),Pkg.Name()); return false; } if (State.CandidateVer == 0 && Remove == false) { if (Pkg->ProvidesList != 0) { // Is one of the options installed? pkgCache::PrvIterator I = Pkg.ProvidesList(); for (; I.end() == false; I++) { pkgCache::PkgIterator pkg = I.OwnerPkg(); if (pkg->CurrentVer != 0) { ioprintf(c1out,_("Virtual Package %s has fufilled dependancies.\n"),Pkg.Name()); // Don't try to compile a virtual package. Cache.MarkSource(Pkg, false); return true; } } } else { ioprintf(c1out, _("Package %s has no available version, but exists in the database.\n" "This typically means that the package was mentioned in a dependency and\n" "never uploaded, has been obsoleted or is not available with the contents\n" "of sources.list\n"),Pkg.Name()); string List; SPtrArray Seen = new bool[Cache->Head().PackageCount]; memset(Seen,0,Cache->Head().PackageCount*sizeof(*Seen)); pkgCache::DepIterator Dep = Pkg.RevDependsList(); for (; Dep.end() == false; Dep++) { if (Dep->Type != pkgCache::Dep::Replaces) continue; if (Seen[Dep.ParentPkg()->ID] == true) continue; Seen[Dep.ParentPkg()->ID] = true; List += string(Dep.ParentPkg().Name()) + " "; } ShowList(c1out,_("However the following packages replace it:"),List); } if (!warning) _error->Error(_("Package %s has no installation candidate"),Pkg.Name()); return false; } Fix.Clear(Pkg); Fix.Protect(Pkg); if (Remove == true) { Fix.Remove(Pkg); Cache->MarkDelete(Pkg,_config->FindB("APT::Get::Purge",false)); return true; } string Src; pkgSrcRecords::Parser *Last = FindSrc(Pkg.Name(),Recs,SrcRecs,Src,Cache); if (Last == 0) { if (!warning) _error->Error(_("Unable to find a source package for %s"),Pkg.Name()); return false; } // Process the build-dependencies vector BuildDeps; if (Last->BuildDepends(BuildDeps) == false) { if (!warning)_error->Error(_("Unable to get build-dependency information for %s"),Src.c_str()); return false; } if (BuildDeps.size() == 0) { // Try to compile anyway if (_config->FindB("APT::Get::Build-All",false) == true) { Cache->MarkInstall(Pkg,false); Cache.MarkSource(Pkg, true); return true; } if (!warning) _error->Error(_("%s has no build depends. (Try apt-src -b install)"),Src.c_str()); return false; } // Install the build-dependancies vector ::iterator D; for (D = BuildDeps.begin(); D != BuildDeps.end(); D++) { pkgCache::PkgIterator Pkg2 = Cache->FindPkg((*D).Package); if (Pkg2.end() == true) { if (!warning) _error->Error(_("%s dependency on %s cannot be satisfied because the package %s cannot be found"), Last->BuildDepType((*D).Type),Src.c_str(),(*D).Package.c_str()); return false; } pkgCache::VerIterator IV = Cache[Pkg2].InstVerIter(Cache); if ((*D).Type == pkgSrcRecords::Parser::BuildConflict || (*D).Type == pkgSrcRecords::Parser::BuildConflictIndep) { /* * conflict; need to remove if we have an installed version * that satisfies the version criterial */ if (IV.end() == false && Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true) { // Are we allowed to add or remove packages? if (InstRem == false) { ioprintf(c1out,_("Bailing out: Package %s is not allowed to be removed1\n"),Pkg2.Name()); return false; } else { if (!TryToInstallDeps(Pkg2,Cache,Fix,true,false,ExpectedInst,Recs,SrcRecs, InstRem,true,recursion + 1)) { ioprintf(c1out,_("Bailing out: Package %s is not allowed to be removed2\n"),Pkg2.Name()); return false; } } } } else { /* * If this is a virtual package, we need to check the list of * packages that provide it and see if any of those are * installed */ pkgCache::PrvIterator Prv = Pkg2.ProvidesList(); for (; Prv.end() != true; Prv++) if (Cache[Prv.OwnerPkg()].InstVerIter(Cache).end() == false) break; if (Prv.end() == true) { /* * depends; need to install or upgrade if we don't have the * package installed or if the version does not satisfy the * build dep. This is complicated by the fact that if we * depend on a version lower than what we already have * installed it is not clear what should be done; in practice * this case should be rare though and right now nothing * is done about it :-( */ if (IV.end() == true || Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == false) { if (HasBuildDeps(Pkg2, Cache, Recs, SrcRecs) || (InstRem == true)) { /* * Only install if we are allowed to. * (If InstRem is not set, we can only upgrade.) */ if (((InstRem == true) || (Cache[Pkg2].InstallVer != 0)) && TryToInstallDeps(Pkg2,Cache,Fix,false,false,ExpectedInst,Recs,SrcRecs, InstRem,true,recursion+1)) { continue; } } ioprintf(c1out,"Bailing out: Package %s cannot be compiled right now.\n", Pkg2.Name()); return false; } } } } // Install it Cache->MarkInstall(Pkg,false); if (State.Install() == false) { if (_config->FindB("APT::Get::ReInstall",false) == true) { if (Pkg->CurrentVer == 0 || Pkg.CurrentVer().Downloadable() == false) ioprintf(c1out,_("Sorry, re-installation of %s is not possible, it cannot be downloaded.\n"), Pkg.Name()); else Cache->SetReInstall(Pkg,true); } } else ExpectedInst++; // Mark the package Cache.MarkSource(Pkg, true); return true; } /*}}}*/ // FixSource - Make sure we are loading all package dependancies as source /*{{{*/ // --------------------------------------------------------------------- static bool FixSource(CacheFile &Cache,pkgRecords &Recs,pkgSrcRecords &SrcRecs, pkgProblemResolver &Fix, bool distupgrade = false) { int count = 0; unsigned int old_expected = 0; while (count < 50) { unsigned int ExpectedInst = 0; for (unsigned I = 0; I < Cache->Head().PackageCount; I++) { pkgCache::PkgIterator pkg(Cache,Cache.List[I]); if (Cache[pkg].Upgrade() == false && Cache[pkg].NewInstall() == false && !(Cache[pkg].iFlags & pkgDepCache::ReInstall)) { // Not using this package. Cache.MarkSource(pkg,false); continue; } // Don't install held packages if (pkg->SelectedState == pkgCache::State::Hold) { Cache.MarkSource(pkg,false); Cache->MarkKeep(pkg); continue; } Cache.MarkSource(pkg,true); // Only installable packages if (!HasBuildDeps(pkg,Cache,Recs,SrcRecs)) { // Try to install the source dependancies if not already there if (!TryToInstallDeps(pkg,Cache,Fix,false,false,ExpectedInst,Recs,SrcRecs,distupgrade)) { // Failed to be installable Cache.MarkSource(pkg,false); Cache->MarkKeep(pkg); ioprintf(cout, "%s has build-deps problem\n", pkg.Name()); } } } // Done? if (Cache->BrokenCount() == 0) return true; // No extra packages? if (ExpectedInst == 0) return true; // Fix any problems if (distupgrade) { if (Fix.Resolve(true) == false) { _error->Discard(); bool done = false; // Remove all packages which build-depend on things which cannot be installed while (!done) { done = true; // Prune out problem packages for (unsigned I = 0; I < Cache->Head().PackageCount; I++) { pkgCache::PkgIterator pkg(Cache,Cache.List[I]); if (Cache[pkg].Upgrade() == false && Cache[pkg].NewInstall() == false && !(Cache[pkg].iFlags & pkgDepCache::ReInstall)) { // Not using this package. continue; } // Only installable packages if (!HasBuildDeps(pkg,Cache,Recs,SrcRecs)) { // Failed to be installable Cache.MarkSource(pkg,false); Cache->MarkKeep(pkg); done = false; } } } } } else { if (Fix.ResolveByKeep() == false) _error->Discard(); } count++; ioprintf(cout, "Looping in FixSource: %d\n",count); if ((old_expected == ExpectedInst) && (count > 4)) { // Exit if are looping too much break; } old_expected = ExpectedInst; } // Timeout - print problems. if (distupgrade) { Fix.Resolve(); } else { Fix.ResolveByKeep(); } return false; } /*}}}*/ // DoInstall - Install packages from the command line /*{{{*/ // --------------------------------------------------------------------- /* Install named packages */ static bool DoInstall(CommandLine &CmdL) { CacheFile Cache; if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false) return false; if (CmdL.FileSize() <= 1) return _error->Error(_("Must specify at least one package to check sources for")); // Read the source list pkgSourceList List; if (List.ReadMainList() == false) return _error->Error(_("The list of sources could not be read.")); // Create the text record parsers pkgRecords Recs(Cache); pkgSrcRecords SrcRecs(List); if (_error->PendingError() == true) return false; // Create the download object AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0)); pkgAcquire Fetcher(&Stat); unsigned int ExpectedInst = 0; unsigned int Packages = 0; pkgProblemResolver Fix(Cache); for (const char **I = CmdL.FileList + 1; *I != 0; I++) { // Install the requested packages unsigned int ExpectedInst = 0; pkgProblemResolver Fix(Cache); // Locate the package pkgCache::PkgIterator Pkg = Cache->FindPkg(*I); if (Pkg.end() == true) return _error->Error(_("The package for %s cannot be found"),*I); // Get the source for its dependancies recursively TryToInstallDeps(Pkg,Cache,Fix,false,true,ExpectedInst,Recs,SrcRecs,true,false); if (Fix.Resolve() == false) { ShowBroken(c1out,Cache,false); return _error->Error(_("Some broken packages were found while trying to process build-dependencies.\n" "You might want to run `apt-get -f install' to correct these.")); } } // Make the list of packages self-consistant if (FixSource(Cache, Recs, SrcRecs, Fix) == false) return false; /* Print out a list of packages that are going to be installed extra to what the user asked */ string XtraPkgList; for (unsigned J = 0; J < Cache->Head().PackageCount; J++) { pkgCache::PkgIterator I(Cache,Cache.List[J]); if ((*Cache)[I].Install() == false) continue; const char **J; for (J = CmdL.FileList + 1; *J != 0; J++) if (strcmp(*J,I.Name()) == 0) break; if (*J == 0) XtraPkgList += string(I.Name()) + " "; } ShowList(c1out,_("The following extra packages will be installed:"),XtraPkgList); // See if we need to prompt if (Cache->InstCount() == ExpectedInst && Cache->DelCount() == 0) { GetSource(Cache, Recs, SrcRecs,false); } else { GetSource(Cache, Recs, SrcRecs); } // Compile them return (CompileSource(Cache, Recs, SrcRecs, true)); } /*}}}*/ // UpgradeHelper - Upgrade all packages from source /*{{{*/ // --------------------------------------------------------------------- /* Upgrade all packages without installing new packages or erasing old packages, using src packages. */ static void UpgradeHelper(CacheFile &Cache, pkgProblemResolver &Fix) { // Upgrade all installed packages for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() == false; I++) { if (_config->FindB("APT::Ignore-Hold",false) == false) if (I->SelectedState == pkgCache::State::Hold) continue; if (I->CurrentVer != 0 && Cache[I].InstallVer != 0) { Cache->MarkInstall(I,false); if (Cache[I].Install() == true) { Cache.MarkSource(I,true); } else { // Not using this package. Cache->MarkKeep(I); } } } // Hold back held packages. if (_config->FindB("APT::Ignore-Hold",false) == false) { for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() == false; I++) { if (I->SelectedState == pkgCache::State::Hold) { Fix.Protect(I); Cache->MarkKeep(I); Cache.MarkSource(I, false); } } } // Minimise download Fix.ResolveByKeep(); } /*}}}*/ // DoDSelectUpgrade - Do an upgrade by following dselects selections /*{{{*/ // --------------------------------------------------------------------- /* Follows dselect's selections */ bool DoDSelectUpgrade(CommandLine &CmdL) { CacheFile Cache; if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false) return false; // Read the source list pkgSourceList List; if (List.ReadMainList() == false) return _error->Error(_("The list of sources could not be read.")); // Create the text record parsers pkgRecords Recs(Cache); pkgSrcRecords SrcRecs(List); if (_error->PendingError() == true) return false; // Install everything with the install flag set pkgCache::PkgIterator I = Cache->PkgBegin(); for (;I.end() != true; I++) { /* Install the package only if it is a new install, the autoupgrader will deal with the rest */ if (I->SelectedState == pkgCache::State::Install) Cache->MarkInstall(I,false); } /* Now install their deps too, if we do this above then order of the status file is significant for | groups */ for (I = Cache->PkgBegin();I.end() != true; I++) { /* Install the package only if it is a new install, the autoupgrader will deal with the rest */ if (I->SelectedState == pkgCache::State::Install) Cache->MarkInstall(I,true); } // Apply erasures now, they override everything else. for (I = Cache->PkgBegin();I.end() != true; I++) { // Remove packages if (I->SelectedState == pkgCache::State::DeInstall || I->SelectedState == pkgCache::State::Purge) Cache->MarkDelete(I,I->SelectedState == pkgCache::State::Purge); } pkgProblemResolver Fix(Cache); /* Resolve any problems that dselect created, allupgrade cannot handle such things. We do so quite agressively too.. */ if (Cache->BrokenCount() != 0) { // Hold back held packages. if (_config->FindB("APT::Ignore-Hold",false) == false) { for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() == false; I++) { if (I->SelectedState == pkgCache::State::Hold) { Fix.Protect(I); Cache->MarkKeep(I); } } } if (Fix.Resolve() == false) { ShowBroken(c1out,Cache,false); return _error->Error("Internal Error, problem resolver broke stuff"); } } // Upgrade all installed packages UpgradeHelper(Cache, Fix); // Make sure build-dependencies exist if (FixSource(Cache,Recs,SrcRecs,Fix) == false) { ShowBroken(c1out,Cache,false); return _error->Error(_("Internal Error, FixSource did not converge.")); } // Download the source files GetSource(Cache, Recs, SrcRecs); // Compile them return(CompileSource(Cache, Recs, SrcRecs, true)); } /*}}}*/ // DoUpgrade - Upgrade all packages from source /*{{{*/ // --------------------------------------------------------------------- /* Upgrade all packages without installing new packages or erasing old packages, using src packages. */ static bool DoUpgrade(CommandLine &CmdL) { CacheFile Cache; if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false) return false; // Read the source list pkgSourceList List; if (List.ReadMainList() == false) return _error->Error(_("The list of sources could not be read.")); // Create the text record parsers pkgRecords Recs(Cache); pkgSrcRecords SrcRecs(List); if (_error->PendingError() == true) return false; pkgProblemResolver Fix(Cache); if (Cache->BrokenCount() != 0) return false; // Upgrade all installed packages UpgradeHelper(Cache, Fix); // Make sure build-dependencies exist if (FixSource(Cache,Recs,SrcRecs,Fix) == false) { ShowBroken(c1out,Cache,false); return _error->Error(_("Internal Error, FixSource did not converge.")); } // Download the source files GetSource(Cache, Recs, SrcRecs); // Compile them return(CompileSource(Cache, Recs, SrcRecs)); } /*}}}*/ // DoDistUpgrade - Upgrade all packages from source /*{{{*/ // --------------------------------------------------------------------- /* This autoinstalls every package and then force installs every pre-existing package. This creates the initial set of conditions which most likely contain problems because too many things were installed. The problem resolver is used to resolve the problems. */ static bool DoDistUpgrade(CommandLine &CmdL) { CacheFile Cache; if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false) return false; // Read the source list pkgSourceList List; if (List.ReadMainList() == false) return _error->Error(_("The list of sources could not be read.")); // Create the text record parsers pkgRecords Recs(Cache); pkgSrcRecords SrcRecs(List); if (_error->PendingError() == true) return false; pkgProblemResolver Fix(Cache); if (Cache->BrokenCount() != 0) return false; /* Auto upgrade all installed packages, this provides the basis for the installation */ for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() == false; I++) if (I->CurrentVer != 0) { Cache->MarkInstall(I,true); } /* Now, auto upgrade all essential packages - this ensures that the essential packages are present and working */ for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() == false; I++) if ((I->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential) { Cache->MarkInstall(I,true); } /* We do it again over all previously installed packages to force conflict resolution on them all. */ for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() == false; I++) if (I->CurrentVer != 0) { Cache->MarkInstall(I,false); } // Hold back held packages. if (_config->FindB("APT::Ignore-Hold",false) == false) { for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() == false; I++) { if (I->SelectedState == pkgCache::State::Hold) { Fix.Protect(I); Cache->MarkKeep(I); } } } Fix.Resolve(); // Make sure build-dependencies exist if (FixSource(Cache,Recs,SrcRecs,Fix,true) == false) { ShowBroken(c1out,Cache,false); return _error->Error(_("Internal Error, FixSource did not converge.")); } // Download the source files GetSource(Cache, Recs, SrcRecs); // Compile them return(CompileSource(Cache, Recs, SrcRecs, true)); } /*}}}*/ // DoMoo - Never Ask, Never Tell /*{{{*/ // --------------------------------------------------------------------- /* */ static bool DoMoo(CommandLine &CmdL) { cout << " (__) \n" " (oo) \n" " /------\\/ \n" " / | || \n" " * /\\---/\\ \n" " ~~ ~~ \n" "....\"Have you mooed today?\"...\n"; return true; } /*}}}*/ // ShowHelp - Show a help screen /*{{{*/ // --------------------------------------------------------------------- /* */ static bool ShowHelp(CommandLine &CmdL) { ioprintf(cout,_("%s %s for %s %s compiled on %s %s\n"),PACKAGE,VERSION, COMMON_OS,COMMON_CPU,__DATE__,__TIME__); if (_config->FindB("version") == true) { cout << _("Supported Modules:") << endl; for (unsigned I = 0; I != pkgVersioningSystem::GlobalListLen; I++) { pkgVersioningSystem *VS = pkgVersioningSystem::GlobalList[I]; if (_system != 0 && _system->VS == VS) cout << '*'; else cout << ' '; cout << "Ver: " << VS->Label << endl; /* Print out all the packaging systems that will work with this VS */ for (unsigned J = 0; J != pkgSystem::GlobalListLen; J++) { pkgSystem *Sys = pkgSystem::GlobalList[J]; if (_system == Sys) cout << '*'; else cout << ' '; if (Sys->VS->TestCompatibility(*VS) == true) cout << "Pkg: " << Sys->Label << " (Priority " << Sys->Score(*_config) << ")" << endl; } } for (unsigned I = 0; I != pkgSourceList::Type::GlobalListLen; I++) { pkgSourceList::Type *Type = pkgSourceList::Type::GlobalList[I]; cout << " S.L: '" << Type->Name << "' " << Type->Label << endl; } for (unsigned I = 0; I != pkgIndexFile::Type::GlobalListLen; I++) { pkgIndexFile::Type *Type = pkgIndexFile::Type::GlobalList[I]; cout << " Idx: " << Type->Label << endl; } return true; } cout << _("Usage: apt-src [options] command\n" " apt-src [options] install|remove pkg1 [pkg2 ...]\n" " apt-src [options] source pkg1 [pkg2 ...]\n" "\n" "apt-src is a simple command line interface for downloading and\n" "installing packages. The most frequently used commands are update\n" "and install. It is similar to apt-get, but will install packages\n" "directly from source. By using a wrapper around your compiler\n" "you can optimise the generated binaries to your system.\n" "\n" "Commands:\n" " update - Retrieve new lists of packages\n" " upgrade - Perform an upgrade\n" " install - Install new packages from source\n" " remove - Remove packages\n" " dist-upgrade - Distribution upgrade, see apt-get(8)\n" " dselect-upgrade - Follow dselect selections\n" " clean - Erase downloaded archive files\n" " check - Verify that there are no broken dependencies\n" "\n" "Options:\n" " -h This help text.\n" " -b Try to install packages without build-depends.\n" " -q Loggable output - no progress indicator\n" " -qq No output except for errors\n" " -d Download only - do NOT install or unpack archives\n" " -s No-act. Perform ordering simulation\n" " -y Assume Yes to all queries and do not prompt\n" " -f Attempt to continue if the integrity check fails\n" " -m Attempt to continue if archives are unlocatable\n" " -u Show a list of upgraded packages as well\n" " -c=? Read this configuration file\n" " -o=? Set an arbitary configuration option, eg -o dir::cache=/tmp\n" "See the apt-get(8), sources.list(5) and apt.conf(5) manual\n" "pages for more information and options.\n" " This APT has Super Cow Powers.\n"); return true; } /*}}}*/ // GetInitialize - Initialize things for apt-get /*{{{*/ // --------------------------------------------------------------------- /* */ static void GetInitialize() { _config->Set("quiet",0); _config->Set("help",false); _config->Set("APT::Get::Download-Only",false); _config->Set("APT::Get::Simulate",false); _config->Set("APT::Get::Assume-Yes",false); _config->Set("APT::Get::Fix-Broken",false); _config->Set("APT::Get::Force-Yes",false); _config->Set("APT::Get::APT::Get::No-List-Cleanup",true); } /*}}}*/ // SigWinch - Window size change signal handler /*{{{*/ // --------------------------------------------------------------------- /* */ static void SigWinch(int) { // Riped from GNU ls #ifdef TIOCGWINSZ struct winsize ws; if (ioctl(1, TIOCGWINSZ, &ws) != -1 && ws.ws_col >= 5) ScreenWidth = ws.ws_col - 1; #endif } /*}}}*/ int main(int argc,const char *argv[]) { CommandLine::Args Args[] = { {'h',"help","help",0}, {'v',"version","version",0}, {'q',"quiet","quiet",CommandLine::IntLevel}, {'q',"silent","quiet",CommandLine::IntLevel}, {'d',"download-only","APT::Get::Download-Only",0}, {'b',"build-all","APT::Get::Build-All",0}, {'s',"simulate","APT::Get::Simulate",0}, {'s',"just-print","APT::Get::Simulate",0}, {'s',"recon","APT::Get::Simulate",0}, {'s',"dry-run","APT::Get::Simulate",0}, {'s',"no-act","APT::Get::Simulate",0}, {'y',"yes","APT::Get::Assume-Yes",0}, {'y',"assume-yes","APT::Get::Assume-Yes",0}, {'f',"fix-broken","APT::Get::Fix-Broken",0}, {'u',"show-upgraded","APT::Get::Show-Upgraded",0}, {'m',"ignore-missing","APT::Get::Fix-Missing",0}, {'t',"target-release","APT::Default-Release",CommandLine::HasArg}, {'t',"default-release","APT::Default-Release",CommandLine::HasArg}, {0,"download","APT::Get::Download",0}, {0,"fix-missing","APT::Get::Fix-Missing",0}, {0,"ignore-hold","APT::Ignore-Hold",0}, {0,"upgrade","APT::Get::upgrade",0}, {0,"force-yes","APT::Get::force-yes",0}, {0,"print-uris","APT::Get::Print-URIs",0}, {0,"diff-only","APT::Get::Diff-Only",0}, {0,"tar-only","APT::Get::tar-Only",0}, {0,"purge","APT::Get::Purge",0}, {0,"list-cleanup","APT::Get::List-Cleanup",0}, {0,"reinstall","APT::Get::ReInstall",0}, {0,"trivial-only","APT::Get::Trivial-Only",0}, {0,"remove","APT::Get::Remove",0}, {0,"only-source","APT::Get::Only-Source",0}, {'c',"config-file",0,CommandLine::ConfigFile}, {'o',"option",0,CommandLine::ArbItem}, {0,0,0,0}}; CommandLine::Dispatch Cmds[] = {{"update",&DoUpdate}, {"upgrade",&DoUpgrade}, {"install",&DoInstall}, {"dist-upgrade",&DoDistUpgrade}, {"dselect-upgrade",&DoDSelectUpgrade}, {"clean",&DoClean}, {"check",&DoCheck}, {"source",&DoSource}, {"moo",&DoMoo}, {"help",&ShowHelp}, {0,0}}; // Parse the command line and initialize the package library CommandLine CmdL(Args,_config); if (pkgInitConfig(*_config) == false || CmdL.Parse(argc,argv) == false || pkgInitSystem(*_config,_system) == false) { if (_config->FindB("version") == true) ShowHelp(CmdL); _error->DumpErrors(); return 100; } // See if the help should be shown if (_config->FindB("help") == true || _config->FindB("version") == true || CmdL.FileSize() == 0) { ShowHelp(CmdL); return 0; } // Deal with stdout not being a tty if (ttyname(STDOUT_FILENO) == 0 && _config->FindI("quiet",0) < 1) _config->Set("quiet","1"); // Setup the output streams c0out.rdbuf(cout.rdbuf()); c1out.rdbuf(cout.rdbuf()); c2out.rdbuf(cout.rdbuf()); if (_config->FindI("quiet",0) > 0) c0out.rdbuf(devnull.rdbuf()); if (_config->FindI("quiet",0) > 1) c1out.rdbuf(devnull.rdbuf()); // Setup the signals signal(SIGPIPE,SIG_IGN); signal(SIGWINCH,SigWinch); SigWinch(0); // Match the operation CmdL.DispatchArg(Cmds); // Print any errors or warnings found during parsing if (_error->empty() == false) { bool Errors = _error->PendingError(); _error->DumpErrors(); return Errors == true?100:0; } return 0; }