1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
|
#ifndef APT_PRIVATE_INSTALL_H
#define APT_PRIVATE_INSTALL_H
#include <apt-pkg/cachefile.h>
#include <apt-pkg/configuration.h>
#include <apt-pkg/depcache.h>
#include <apt-pkg/pkgcache.h>
#include <apt-pkg/cacheiterators.h>
#include <apt-pkg/cacheset.h>
#include <apt-pkg/strutl.h>
#include <apt-pkg/algorithms.h>
#include <apt-pkg/macros.h>
#include <apt-private/private-output.h>
#include <stddef.h>
#include <iosfwd>
#include <list>
#include <map>
#include <string>
#include <utility>
#include <apti18n.h>
class CacheFile;
class CommandLine;
#define RAMFS_MAGIC 0x858458f6
APT_PUBLIC bool DoInstall(CommandLine &Cmd);
bool DoCacheManipulationFromCommandLine(CommandLine &CmdL, CacheFile &Cache,
std::map<unsigned short, APT::VersionSet> &verset);
bool DoCacheManipulationFromCommandLine(CommandLine &CmdL, CacheFile &Cache);
APT_PUBLIC bool InstallPackages(CacheFile &Cache,bool ShwKept,bool Ask = true,
bool Safety = true);
// TryToInstall - Mark a package for installation /*{{{*/
struct TryToInstall {
pkgCacheFile* Cache;
pkgProblemResolver* Fix;
bool FixBroken;
unsigned long AutoMarkChanged;
APT::PackageSet doAutoInstallLater;
TryToInstall(pkgCacheFile &Cache, pkgProblemResolver *PM, bool const FixBroken) : Cache(&Cache), Fix(PM),
FixBroken(FixBroken), AutoMarkChanged(0) {};
void operator() (pkgCache::VerIterator const &Ver) {
pkgCache::PkgIterator Pkg = Ver.ParentPkg();
Cache->GetDepCache()->SetCandidateVersion(Ver);
pkgDepCache::StateCache &State = (*Cache)[Pkg];
// Handle the no-upgrade case
if (_config->FindB("APT::Get::upgrade",true) == false && Pkg->CurrentVer != 0)
ioprintf(c1out,_("Skipping %s, it is already installed and upgrade is not set.\n"),
Pkg.FullName(true).c_str());
// Ignore request for install if package would be new
else if (_config->FindB("APT::Get::Only-Upgrade", false) == true && Pkg->CurrentVer == 0)
ioprintf(c1out,_("Skipping %s, it is not installed and only upgrades are requested.\n"),
Pkg.FullName(true).c_str());
else {
if (Fix != NULL) {
Fix->Clear(Pkg);
Fix->Protect(Pkg);
}
Cache->GetDepCache()->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,_("Reinstallation of %s is not possible, it cannot be downloaded.\n"),
Pkg.FullName(true).c_str());
else
Cache->GetDepCache()->SetReInstall(Pkg, true);
} else
ioprintf(c1out,_("%s is already the newest version.\n"),
Pkg.FullName(true).c_str());
}
// Install it with autoinstalling enabled (if we not respect the minial
// required deps or the policy)
if (FixBroken == false)
doAutoInstallLater.insert(Pkg);
}
// see if we need to fix the auto-mark flag
// e.g. apt-get install foo
// where foo is marked automatic
if (State.Install() == false &&
(State.Flags & pkgCache::Flag::Auto) &&
_config->FindB("APT::Get::ReInstall",false) == false &&
_config->FindB("APT::Get::Only-Upgrade",false) == false &&
_config->FindB("APT::Get::Download-Only",false) == false)
{
ioprintf(c1out,_("%s set to manually installed.\n"),
Pkg.FullName(true).c_str());
Cache->GetDepCache()->MarkAuto(Pkg,false);
AutoMarkChanged++;
}
}
bool propergateReleaseCandiateSwitching(std::list<std::pair<pkgCache::VerIterator, std::string> > start, std::ostream &out)
{
for (std::list<std::pair<pkgCache::VerIterator, std::string> >::const_iterator s = start.begin();
s != start.end(); ++s)
Cache->GetDepCache()->SetCandidateVersion(s->first);
bool Success = true;
// the Changed list contains:
// first: "new version"
// second: "what-caused the change"
std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> > Changed;
for (std::list<std::pair<pkgCache::VerIterator, std::string> >::const_iterator s = start.begin();
s != start.end(); ++s)
{
Changed.push_back(std::make_pair(s->first, pkgCache::VerIterator(*Cache)));
// We continue here even if it failed to enhance the ShowBroken output
Success &= Cache->GetDepCache()->SetCandidateRelease(s->first, s->second, Changed);
}
for (std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> >::const_iterator c = Changed.begin();
c != Changed.end(); ++c)
{
if (c->second.end() == true)
ioprintf(out, _("Selected version '%s' (%s) for '%s'\n"),
c->first.VerStr(), c->first.RelStr().c_str(), c->first.ParentPkg().FullName(true).c_str());
else if (c->first.ParentPkg()->Group != c->second.ParentPkg()->Group)
{
pkgCache::VerIterator V = (*Cache)[c->first.ParentPkg()].CandidateVerIter(*Cache);
ioprintf(out, _("Selected version '%s' (%s) for '%s' because of '%s'\n"), V.VerStr(),
V.RelStr().c_str(), V.ParentPkg().FullName(true).c_str(), c->second.ParentPkg().FullName(true).c_str());
}
}
return Success;
}
void doAutoInstall() {
for (APT::PackageSet::const_iterator P = doAutoInstallLater.begin();
P != doAutoInstallLater.end(); ++P) {
pkgDepCache::StateCache &State = (*Cache)[P];
if (State.InstBroken() == false && State.InstPolicyBroken() == false)
continue;
Cache->GetDepCache()->MarkInstall(P, true);
}
doAutoInstallLater.clear();
}
};
/*}}}*/
// TryToRemove - Mark a package for removal /*{{{*/
struct TryToRemove {
pkgCacheFile* Cache;
pkgProblemResolver* Fix;
bool PurgePkgs;
TryToRemove(pkgCacheFile &Cache, pkgProblemResolver *PM) : Cache(&Cache), Fix(PM),
PurgePkgs(_config->FindB("APT::Get::Purge", false)) {};
void operator() (pkgCache::VerIterator const &Ver)
{
pkgCache::PkgIterator Pkg = Ver.ParentPkg();
if (Fix != NULL)
{
Fix->Clear(Pkg);
Fix->Protect(Pkg);
Fix->Remove(Pkg);
}
if ((Pkg->CurrentVer == 0 && PurgePkgs == false) ||
(PurgePkgs == true && Pkg->CurrentState == pkgCache::State::NotInstalled))
{
pkgCache::GrpIterator Grp = Pkg.Group();
pkgCache::PkgIterator P = Grp.PackageList();
for (; P.end() != true; P = Grp.NextPkg(P))
{
if (P == Pkg)
continue;
if (P->CurrentVer != 0 || (PurgePkgs == true && P->CurrentState != pkgCache::State::NotInstalled))
{
// TRANSLATORS: Note, this is not an interactive question
ioprintf(c1out,_("Package '%s' is not installed, so not removed. Did you mean '%s'?\n"),
Pkg.FullName(true).c_str(), P.FullName(true).c_str());
break;
}
}
if (P.end() == true)
ioprintf(c1out,_("Package '%s' is not installed, so not removed\n"),Pkg.FullName(true).c_str());
// MarkInstall refuses to install packages on hold
Pkg->SelectedState = pkgCache::State::Hold;
}
else
Cache->GetDepCache()->MarkDelete(Pkg, PurgePkgs);
}
};
/*}}}*/
#endif
|
