Commit | Line | Data |
---|---|---|
6d38011b DK |
1 | // -*- mode: cpp; mode: fold -*- |
2 | // Description /*{{{*/ | |
3 | /* ###################################################################### | |
4 | Set of methods to help writing and reading everything needed for EDSP | |
5 | ##################################################################### */ | |
6 | /*}}}*/ | |
7 | // Include Files /*{{{*/ | |
c3b85126 | 8 | #include <apt-pkg/edsp.h> |
6d38011b DK |
9 | #include <apt-pkg/error.h> |
10 | #include <apt-pkg/configuration.h> | |
11 | #include <apt-pkg/version.h> | |
12 | #include <apt-pkg/policy.h> | |
13 | ||
14 | #include <apti18n.h> | |
15 | #include <limits> | |
16 | ||
17 | #include <stdio.h> | |
18 | /*}}}*/ | |
19 | ||
c3b85126 DK |
20 | // EDSP::WriteScenario - to the given file descriptor /*{{{*/ |
21 | bool EDSP::WriteScenario(pkgDepCache &Cache, FILE* output) | |
6d38011b DK |
22 | { |
23 | // we could use pkgCache::DepType and ::Priority, but these would be lokalized stringsā¦ | |
24 | const char * const PrioMap[] = {0, "important", "required", "standard", | |
25 | "optional", "extra"}; | |
26 | const char * const DepMap[] = {"", "Depends", "PreDepends", "Suggests", | |
27 | "Recommends" , "Conflicts", "Replaces", | |
28 | "Obsoletes", "Breaks", "Enhances"}; | |
29 | ||
30 | for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg) | |
31 | { | |
32 | for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver) | |
33 | { | |
34 | fprintf(output, "Package: %s\n", Pkg.Name()); | |
35 | fprintf(output, "Architecture: %s\n", Ver.Arch()); | |
36 | fprintf(output, "Version: %s\n", Ver.VerStr()); | |
37 | if (Pkg.CurrentVer() == Ver) | |
38 | fprintf(output, "Installed: yes\n"); | |
39 | if (Pkg->SelectedState == pkgCache::State::Hold) | |
40 | fprintf(output, "Hold: yes\n"); | |
41 | fprintf(output, "APT-ID: %u\n", Ver->ID); | |
42 | fprintf(output, "Priority: %s\n", PrioMap[Ver->Priority]); | |
43 | if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential) | |
44 | fprintf(output, "Essential: yes\n"); | |
45 | fprintf(output, "Section: %s\n", Ver.Section()); | |
46 | if (Ver->MultiArch == pkgCache::Version::Allowed || Ver->MultiArch == pkgCache::Version::AllAllowed) | |
47 | fprintf(output, "Multi-Arch: allowed\n"); | |
48 | else if (Ver->MultiArch == pkgCache::Version::Foreign || Ver->MultiArch == pkgCache::Version::AllForeign) | |
49 | fprintf(output, "Multi-Arch: foreign\n"); | |
50 | else if (Ver->MultiArch == pkgCache::Version::Same) | |
51 | fprintf(output, "Multi-Arch: same\n"); | |
52 | signed short Pin = std::numeric_limits<signed short>::min(); | |
53 | for (pkgCache::VerFileIterator File = Ver.FileList(); File.end() == false; ++File) { | |
54 | signed short const p = Cache.GetPolicy().GetPriority(File.File()); | |
55 | if (Pin < p) | |
56 | Pin = p; | |
57 | } | |
58 | fprintf(output, "APT-Pin: %d\n", Pin); | |
59 | if (Cache.GetCandidateVer(Pkg) == Ver) | |
60 | fprintf(output, "APT-Candidate: yes\n"); | |
61 | if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto) | |
62 | fprintf(output, "APT-Automatic: yes\n"); | |
63 | std::string dependencies[pkgCache::Dep::Enhances + 1]; | |
64 | bool orGroup = false; | |
65 | for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep) | |
66 | { | |
67 | // Ignore implicit dependencies for multiarch here | |
68 | if (strcmp(Pkg.Arch(), Dep.TargetPkg().Arch()) != 0) | |
69 | continue; | |
70 | if (orGroup == false) | |
71 | dependencies[Dep->Type].append(", "); | |
72 | dependencies[Dep->Type].append(Dep.TargetPkg().Name()); | |
73 | if (Dep->Version != 0) | |
74 | dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")"); | |
75 | if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or) | |
76 | { | |
77 | dependencies[Dep->Type].append(" | "); | |
78 | orGroup = true; | |
79 | } | |
80 | else | |
81 | orGroup = false; | |
82 | } | |
83 | for (int i = 1; i < pkgCache::Dep::Enhances + 1; ++i) | |
84 | if (dependencies[i].empty() == false) | |
85 | fprintf(output, "%s: %s\n", DepMap[i], dependencies[i].c_str()+2); | |
86 | string provides; | |
87 | for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv) | |
88 | { | |
89 | // Ignore implicit provides for multiarch here | |
90 | if (strcmp(Pkg.Arch(), Prv.ParentPkg().Arch()) != 0 || strcmp(Pkg.Name(),Prv.Name()) == 0) | |
91 | continue; | |
92 | provides.append(", ").append(Prv.Name()); | |
93 | } | |
94 | if (provides.empty() == false) | |
95 | fprintf(output, "Provides: %s\n", provides.c_str()+2); | |
96 | ||
97 | ||
98 | fprintf(output, "\n"); | |
99 | } | |
100 | } | |
101 | return true; | |
102 | } | |
103 | /*}}}*/ | |
c3b85126 | 104 | // EDSP::WriteRequest - to the given file descriptor /*{{{*/ |
93794bc9 DK |
105 | bool EDSP::WriteRequest(pkgDepCache &Cache, FILE* output, bool const Upgrade, |
106 | bool const DistUpgrade, bool const AutoRemove) | |
6d38011b | 107 | { |
93794bc9 | 108 | string del, inst; |
6d38011b DK |
109 | for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg) |
110 | { | |
111 | string* req; | |
112 | if (Cache[Pkg].Delete() == true) | |
113 | req = &del; | |
93794bc9 | 114 | else if (Cache[Pkg].NewInstall() == true || Cache[Pkg].Upgrade() == true) |
6d38011b | 115 | req = &inst; |
6d38011b DK |
116 | else |
117 | continue; | |
6d5bd614 | 118 | req->append(" ").append(Pkg.FullName()); |
6d38011b | 119 | } |
93794bc9 | 120 | fprintf(output, "Request: EDSP 0.2\n"); |
6d38011b | 121 | if (del.empty() == false) |
6d5bd614 | 122 | fprintf(output, "Remove: %s\n", del.c_str()+1); |
6d38011b | 123 | if (inst.empty() == false) |
6d5bd614 | 124 | fprintf(output, "Install: %s\n", inst.c_str()+1); |
93794bc9 DK |
125 | if (Upgrade == true) |
126 | fprintf(output, "Upgrade: yes\n"); | |
127 | if (DistUpgrade == true) | |
128 | fprintf(output, "Dist-Upgrade: yes\n"); | |
129 | if (AutoRemove == true) | |
130 | fprintf(output, "Autoremove: yes\n"); | |
131 | if (_config->FindB("APT::Solver::Strict-Pinning", true) == false) | |
132 | fprintf(output, "Strict-Pinning: no\n"); | |
133 | string solverpref("APT::Solver::"); | |
134 | solverpref.append(_config->Find("APT::Solver::Name", "internal")).append("::Preferences"); | |
6d5bd614 | 135 | if (_config->Exists(solverpref) == true) |
93794bc9 | 136 | fprintf(output, "Preferences: %s\n", _config->Find(solverpref,"").c_str()); |
6d5bd614 | 137 | fprintf(output, "\n"); |
6d38011b | 138 | |
e3674d91 DK |
139 | return true; |
140 | } | |
141 | /*}}}*/ | |
c3b85126 | 142 | bool EDSP::ReadResponse(FILE* input, pkgDepCache &Cache) { return false; } |
29099cb6 | 143 | |
6d5bd614 DK |
144 | // EDSP::ReadLine - first line from the given file descriptor /*{{{*/ |
145 | // --------------------------------------------------------------------- | |
146 | /* Little helper method to read a complete line into a string. Similar to | |
147 | fgets but we need to use the low-level read() here as otherwise the | |
148 | listparser will be confused later on as mixing of fgets and read isn't | |
149 | a supported action according to the manpages and result are undefined */ | |
150 | bool EDSP::ReadLine(int const input, std::string &line) { | |
151 | char one; | |
152 | ssize_t data = 0; | |
153 | line.erase(); | |
154 | line.reserve(100); | |
155 | while ((data = read(input, &one, sizeof(one))) != -1) { | |
156 | if (data != 1) | |
157 | continue; | |
158 | if (one == '\n') | |
159 | return true; | |
160 | if (one == '\r') | |
161 | continue; | |
162 | if (line.empty() == true && isblank(one) != 0) | |
163 | continue; | |
164 | line += one; | |
165 | } | |
166 | return false; | |
167 | } | |
168 | /*}}}*/ | |
169 | // EDSP::ReadRequest - first stanza from the given file descriptor /*{{{*/ | |
170 | bool EDSP::ReadRequest(int const input, std::list<std::string> &install, | |
29099cb6 | 171 | std::list<std::string> &remove) |
6d5bd614 DK |
172 | { |
173 | std::string line; | |
174 | while (ReadLine(input, line) == true) | |
175 | { | |
176 | // Skip empty lines before request | |
177 | if (line.empty() == true) | |
178 | continue; | |
179 | // The first Tag must be a request, so search for it | |
180 | if (line.compare(0,8, "Request:") != 0) | |
181 | continue; | |
182 | ||
183 | while (ReadLine(input, line) == true) | |
184 | { | |
185 | // empty lines are the end of the request | |
186 | if (line.empty() == true) | |
187 | return true; | |
188 | ||
189 | std::list<std::string> *request = NULL; | |
190 | if (line.compare(0,8, "Install:") == 0) | |
191 | { | |
192 | line.erase(0,8); | |
193 | request = &install; | |
194 | } | |
195 | if (line.compare(0,7, "Remove:") == 0) | |
196 | { | |
197 | line.erase(0,7); | |
198 | request = &remove; | |
199 | } | |
200 | if (request == NULL) | |
201 | continue; | |
202 | size_t end = line.length(); | |
203 | do { | |
204 | size_t begin = line.rfind(' '); | |
205 | if (begin == std::string::npos) | |
206 | { | |
207 | request->push_back(line.substr(0,end)); | |
208 | break; | |
209 | } | |
210 | else if (begin < end) | |
211 | request->push_back(line.substr(begin + 1, end)); | |
212 | line.erase(begin); | |
213 | end = line.find_last_not_of(' '); | |
214 | } while (end != std::string::npos); | |
215 | } | |
216 | } | |
217 | return false; | |
218 | } | |
219 | /*}}}*/ | |
220 | // EDSP::ApplyRequest - first stanza from the given file descriptor /*{{{*/ | |
c3b85126 | 221 | bool EDSP::ApplyRequest(std::list<std::string> const &install, |
29099cb6 DK |
222 | std::list<std::string> const &remove, |
223 | pkgDepCache &Cache) | |
6d5bd614 DK |
224 | { |
225 | for (std::list<std::string>::const_iterator i = install.begin(); | |
226 | i != install.end(); ++i) | |
227 | Cache.MarkInstall(Cache.FindPkg(*i), false); | |
228 | ||
229 | for (std::list<std::string>::const_iterator i = remove.begin(); | |
230 | i != remove.end(); ++i) | |
231 | Cache.MarkDelete(Cache.FindPkg(*i)); | |
232 | return true; | |
233 | } | |
234 | /*}}}*/ | |
c3b85126 DK |
235 | // EDSP::WriteSolution - to the given file descriptor /*{{{*/ |
236 | bool EDSP::WriteSolution(pkgDepCache &Cache, FILE* output) | |
e3674d91 | 237 | { |
6d5bd614 | 238 | bool const Debug = _config->FindB("Debug::EDSP::WriteSolution", false); |
e3674d91 DK |
239 | for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg) |
240 | { | |
241 | if (Cache[Pkg].Delete() == true) | |
242 | fprintf(output, "Remove: %d\n", Cache.GetCandidateVer(Pkg)->ID); | |
243 | else if (Cache[Pkg].NewInstall() == true || Cache[Pkg].Upgrade() == true) | |
244 | fprintf(output, "Install: %d\n", Cache.GetCandidateVer(Pkg)->ID); | |
245 | else | |
246 | continue; | |
247 | if (Debug == true) | |
248 | fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Cache.GetCandidateVer(Pkg).VerStr()); | |
249 | fprintf(output, "\n"); | |
250 | } | |
251 | ||
6d38011b DK |
252 | return true; |
253 | } | |
254 | /*}}}*/ | |
c3b85126 | 255 | bool EDSP::WriteError(std::string const &message, FILE* output) { return false; } |