]>
Commit | Line | Data |
---|---|---|
c0c0b100 | 1 | // -*- mode: cpp; mode: fold -*- |
03e39e59 | 2 | // Description /*{{{*/ |
7f9a6360 | 3 | // $Id: dpkgpm.cc,v 1.28 2004/01/27 02:25:01 mdz Exp $ |
03e39e59 AL |
4 | /* ###################################################################### |
5 | ||
6 | DPKG Package Manager - Provide an interface to dpkg | |
7 | ||
8 | ##################################################################### */ | |
9 | /*}}}*/ | |
10 | // Includes /*{{{*/ | |
03e39e59 AL |
11 | #include <apt-pkg/dpkgpm.h> |
12 | #include <apt-pkg/error.h> | |
13 | #include <apt-pkg/configuration.h> | |
b2e465d6 AL |
14 | #include <apt-pkg/depcache.h> |
15 | #include <apt-pkg/strutl.h> | |
a4cf3665 | 16 | #include <apti18n.h> |
614adaa0 | 17 | #include <apt-pkg/fileutl.h> |
233b185f | 18 | |
03e39e59 AL |
19 | #include <unistd.h> |
20 | #include <stdlib.h> | |
21 | #include <fcntl.h> | |
090c6566 | 22 | #include <sys/select.h> |
03e39e59 AL |
23 | #include <sys/types.h> |
24 | #include <sys/wait.h> | |
25 | #include <signal.h> | |
26 | #include <errno.h> | |
db0c350f | 27 | #include <stdio.h> |
f7dec19f DB |
28 | #include <string.h> |
29 | #include <algorithm> | |
75ef8f14 MV |
30 | #include <sstream> |
31 | #include <map> | |
32 | ||
d8cb4aa4 MV |
33 | #include <termios.h> |
34 | #include <unistd.h> | |
35 | #include <sys/ioctl.h> | |
36 | #include <pty.h> | |
37 | ||
75ef8f14 MV |
38 | #include <config.h> |
39 | #include <apti18n.h> | |
b0ebdef5 | 40 | /*}}}*/ |
233b185f AL |
41 | |
42 | using namespace std; | |
03e39e59 | 43 | |
f7dec19f DB |
44 | namespace |
45 | { | |
46 | // Maps the dpkg "processing" info to human readable names. Entry 0 | |
47 | // of each array is the key, entry 1 is the value. | |
48 | const std::pair<const char *, const char *> PackageProcessingOps[] = { | |
49 | std::make_pair("install", N_("Installing %s")), | |
50 | std::make_pair("configure", N_("Configuring %s")), | |
51 | std::make_pair("remove", N_("Removing %s")), | |
ac81ae9c | 52 | std::make_pair("purge", N_("Completely removing %s")), |
f7dec19f DB |
53 | std::make_pair("trigproc", N_("Running post-installation trigger %s")) |
54 | }; | |
55 | ||
56 | const std::pair<const char *, const char *> * const PackageProcessingOpsBegin = PackageProcessingOps; | |
57 | const std::pair<const char *, const char *> * const PackageProcessingOpsEnd = PackageProcessingOps + sizeof(PackageProcessingOps) / sizeof(PackageProcessingOps[0]); | |
58 | ||
59 | // Predicate to test whether an entry in the PackageProcessingOps | |
60 | // array matches a string. | |
61 | class MatchProcessingOp | |
62 | { | |
63 | const char *target; | |
64 | ||
65 | public: | |
66 | MatchProcessingOp(const char *the_target) | |
67 | : target(the_target) | |
68 | { | |
69 | } | |
70 | ||
71 | bool operator()(const std::pair<const char *, const char *> &pair) const | |
72 | { | |
73 | return strcmp(pair.first, target) == 0; | |
74 | } | |
75 | }; | |
76 | } | |
09fa2df2 | 77 | |
cebe0287 MV |
78 | /* helper function to ionice the given PID |
79 | ||
80 | there is no C header for ionice yet - just the syscall interface | |
81 | so we use the binary from util-linux | |
82 | */ | |
83 | static bool | |
84 | ionice(int PID) | |
85 | { | |
86 | if (!FileExists("/usr/bin/ionice")) | |
87 | return false; | |
88 | pid_t Process = ExecFork(); | |
89 | if (Process == 0) | |
90 | { | |
91 | char buf[32]; | |
92 | snprintf(buf, sizeof(buf), "-p%d", PID); | |
93 | const char *Args[4]; | |
94 | Args[0] = "/usr/bin/ionice"; | |
95 | Args[1] = "-c3"; | |
96 | Args[2] = buf; | |
97 | Args[3] = 0; | |
98 | execv(Args[0], (char **)Args); | |
99 | } | |
100 | return ExecWait(Process, "ionice"); | |
101 | } | |
102 | ||
03e39e59 AL |
103 | // DPkgPM::pkgDPkgPM - Constructor /*{{{*/ |
104 | // --------------------------------------------------------------------- | |
105 | /* */ | |
09fa2df2 | 106 | pkgDPkgPM::pkgDPkgPM(pkgDepCache *Cache) |
71afbdb5 OS |
107 | : pkgPackageManager(Cache), dpkgbuf_pos(0), |
108 | term_out(NULL), PackagesDone(0), PackagesTotal(0) | |
03e39e59 AL |
109 | { |
110 | } | |
111 | /*}}}*/ | |
112 | // DPkgPM::pkgDPkgPM - Destructor /*{{{*/ | |
113 | // --------------------------------------------------------------------- | |
114 | /* */ | |
115 | pkgDPkgPM::~pkgDPkgPM() | |
116 | { | |
117 | } | |
118 | /*}}}*/ | |
119 | // DPkgPM::Install - Install a package /*{{{*/ | |
120 | // --------------------------------------------------------------------- | |
121 | /* Add an install operation to the sequence list */ | |
122 | bool pkgDPkgPM::Install(PkgIterator Pkg,string File) | |
123 | { | |
124 | if (File.empty() == true || Pkg.end() == true) | |
125 | return _error->Error("Internal Error, No file name for %s",Pkg.Name()); | |
126 | ||
127 | List.push_back(Item(Item::Install,Pkg,File)); | |
128 | return true; | |
129 | } | |
130 | /*}}}*/ | |
131 | // DPkgPM::Configure - Configure a package /*{{{*/ | |
132 | // --------------------------------------------------------------------- | |
133 | /* Add a configure operation to the sequence list */ | |
134 | bool pkgDPkgPM::Configure(PkgIterator Pkg) | |
135 | { | |
136 | if (Pkg.end() == true) | |
137 | return false; | |
3e9c4f70 | 138 | |
5e312de7 DK |
139 | List.push_back(Item(Item::Configure, Pkg)); |
140 | ||
141 | // Use triggers for config calls if we configure "smart" | |
142 | // as otherwise Pre-Depends will not be satisfied, see #526774 | |
143 | if (_config->FindB("DPkg::TriggersPending", false) == true) | |
144 | List.push_back(Item(Item::TriggersPending, PkgIterator())); | |
3e9c4f70 | 145 | |
03e39e59 AL |
146 | return true; |
147 | } | |
148 | /*}}}*/ | |
149 | // DPkgPM::Remove - Remove a package /*{{{*/ | |
150 | // --------------------------------------------------------------------- | |
151 | /* Add a remove operation to the sequence list */ | |
fc4b5c9f | 152 | bool pkgDPkgPM::Remove(PkgIterator Pkg,bool Purge) |
03e39e59 AL |
153 | { |
154 | if (Pkg.end() == true) | |
155 | return false; | |
156 | ||
fc4b5c9f AL |
157 | if (Purge == true) |
158 | List.push_back(Item(Item::Purge,Pkg)); | |
159 | else | |
160 | List.push_back(Item(Item::Remove,Pkg)); | |
6dd55be7 AL |
161 | return true; |
162 | } | |
163 | /*}}}*/ | |
b2e465d6 AL |
164 | // DPkgPM::SendV2Pkgs - Send version 2 package info /*{{{*/ |
165 | // --------------------------------------------------------------------- | |
166 | /* This is part of the helper script communication interface, it sends | |
167 | very complete information down to the other end of the pipe.*/ | |
168 | bool pkgDPkgPM::SendV2Pkgs(FILE *F) | |
169 | { | |
170 | fprintf(F,"VERSION 2\n"); | |
171 | ||
172 | /* Write out all of the configuration directives by walking the | |
173 | configuration tree */ | |
174 | const Configuration::Item *Top = _config->Tree(0); | |
175 | for (; Top != 0;) | |
176 | { | |
177 | if (Top->Value.empty() == false) | |
178 | { | |
179 | fprintf(F,"%s=%s\n", | |
180 | QuoteString(Top->FullTag(),"=\"\n").c_str(), | |
181 | QuoteString(Top->Value,"\n").c_str()); | |
182 | } | |
183 | ||
184 | if (Top->Child != 0) | |
185 | { | |
186 | Top = Top->Child; | |
187 | continue; | |
188 | } | |
189 | ||
190 | while (Top != 0 && Top->Next == 0) | |
191 | Top = Top->Parent; | |
192 | if (Top != 0) | |
193 | Top = Top->Next; | |
194 | } | |
195 | fprintf(F,"\n"); | |
196 | ||
197 | // Write out the package actions in order. | |
198 | for (vector<Item>::iterator I = List.begin(); I != List.end(); I++) | |
199 | { | |
3e9c4f70 DK |
200 | if(I->Pkg.end() == true) |
201 | continue; | |
202 | ||
b2e465d6 AL |
203 | pkgDepCache::StateCache &S = Cache[I->Pkg]; |
204 | ||
205 | fprintf(F,"%s ",I->Pkg.Name()); | |
206 | // Current version | |
207 | if (I->Pkg->CurrentVer == 0) | |
208 | fprintf(F,"- "); | |
209 | else | |
210 | fprintf(F,"%s ",I->Pkg.CurrentVer().VerStr()); | |
211 | ||
212 | // Show the compare operator | |
213 | // Target version | |
214 | if (S.InstallVer != 0) | |
215 | { | |
216 | int Comp = 2; | |
217 | if (I->Pkg->CurrentVer != 0) | |
218 | Comp = S.InstVerIter(Cache).CompareVer(I->Pkg.CurrentVer()); | |
219 | if (Comp < 0) | |
220 | fprintf(F,"> "); | |
221 | if (Comp == 0) | |
222 | fprintf(F,"= "); | |
223 | if (Comp > 0) | |
224 | fprintf(F,"< "); | |
225 | fprintf(F,"%s ",S.InstVerIter(Cache).VerStr()); | |
226 | } | |
227 | else | |
228 | fprintf(F,"> - "); | |
229 | ||
230 | // Show the filename/operation | |
231 | if (I->Op == Item::Install) | |
232 | { | |
233 | // No errors here.. | |
234 | if (I->File[0] != '/') | |
235 | fprintf(F,"**ERROR**\n"); | |
236 | else | |
237 | fprintf(F,"%s\n",I->File.c_str()); | |
238 | } | |
239 | if (I->Op == Item::Configure) | |
240 | fprintf(F,"**CONFIGURE**\n"); | |
241 | if (I->Op == Item::Remove || | |
242 | I->Op == Item::Purge) | |
243 | fprintf(F,"**REMOVE**\n"); | |
244 | ||
245 | if (ferror(F) != 0) | |
246 | return false; | |
247 | } | |
248 | return true; | |
249 | } | |
250 | /*}}}*/ | |
db0c350f AL |
251 | // DPkgPM::RunScriptsWithPkgs - Run scripts with package names on stdin /*{{{*/ |
252 | // --------------------------------------------------------------------- | |
253 | /* This looks for a list of scripts to run from the configuration file | |
254 | each one is run and is fed on standard input a list of all .deb files | |
255 | that are due to be installed. */ | |
256 | bool pkgDPkgPM::RunScriptsWithPkgs(const char *Cnf) | |
257 | { | |
258 | Configuration::Item const *Opts = _config->Tree(Cnf); | |
259 | if (Opts == 0 || Opts->Child == 0) | |
260 | return true; | |
261 | Opts = Opts->Child; | |
262 | ||
263 | unsigned int Count = 1; | |
264 | for (; Opts != 0; Opts = Opts->Next, Count++) | |
265 | { | |
266 | if (Opts->Value.empty() == true) | |
267 | continue; | |
b2e465d6 AL |
268 | |
269 | // Determine the protocol version | |
270 | string OptSec = Opts->Value; | |
271 | string::size_type Pos; | |
272 | if ((Pos = OptSec.find(' ')) == string::npos || Pos == 0) | |
273 | Pos = OptSec.length(); | |
b2e465d6 AL |
274 | OptSec = "DPkg::Tools::Options::" + string(Opts->Value.c_str(),Pos); |
275 | ||
276 | unsigned int Version = _config->FindI(OptSec+"::Version",1); | |
277 | ||
db0c350f AL |
278 | // Create the pipes |
279 | int Pipes[2]; | |
280 | if (pipe(Pipes) != 0) | |
281 | return _error->Errno("pipe","Failed to create IPC pipe to subprocess"); | |
282 | SetCloseExec(Pipes[0],true); | |
283 | SetCloseExec(Pipes[1],true); | |
284 | ||
285 | // Purified Fork for running the script | |
286 | pid_t Process = ExecFork(); | |
287 | if (Process == 0) | |
288 | { | |
289 | // Setup the FDs | |
290 | dup2(Pipes[0],STDIN_FILENO); | |
291 | SetCloseExec(STDOUT_FILENO,false); | |
292 | SetCloseExec(STDIN_FILENO,false); | |
293 | SetCloseExec(STDERR_FILENO,false); | |
90ecbd7d AL |
294 | |
295 | const char *Args[4]; | |
db0c350f | 296 | Args[0] = "/bin/sh"; |
90ecbd7d AL |
297 | Args[1] = "-c"; |
298 | Args[2] = Opts->Value.c_str(); | |
299 | Args[3] = 0; | |
db0c350f AL |
300 | execv(Args[0],(char **)Args); |
301 | _exit(100); | |
302 | } | |
303 | close(Pipes[0]); | |
b2e465d6 AL |
304 | FILE *F = fdopen(Pipes[1],"w"); |
305 | if (F == 0) | |
306 | return _error->Errno("fdopen","Faild to open new FD"); | |
307 | ||
db0c350f | 308 | // Feed it the filenames. |
b2e465d6 AL |
309 | bool Die = false; |
310 | if (Version <= 1) | |
db0c350f | 311 | { |
b2e465d6 | 312 | for (vector<Item>::iterator I = List.begin(); I != List.end(); I++) |
db0c350f | 313 | { |
b2e465d6 AL |
314 | // Only deal with packages to be installed from .deb |
315 | if (I->Op != Item::Install) | |
316 | continue; | |
317 | ||
318 | // No errors here.. | |
319 | if (I->File[0] != '/') | |
320 | continue; | |
321 | ||
322 | /* Feed the filename of each package that is pending install | |
323 | into the pipe. */ | |
324 | fprintf(F,"%s\n",I->File.c_str()); | |
325 | if (ferror(F) != 0) | |
326 | { | |
327 | Die = true; | |
328 | break; | |
329 | } | |
90ecbd7d | 330 | } |
db0c350f | 331 | } |
b2e465d6 AL |
332 | else |
333 | Die = !SendV2Pkgs(F); | |
334 | ||
335 | fclose(F); | |
db0c350f AL |
336 | |
337 | // Clean up the sub process | |
338 | if (ExecWait(Process,Opts->Value.c_str()) == false) | |
90ecbd7d | 339 | return _error->Error("Failure running script %s",Opts->Value.c_str()); |
db0c350f AL |
340 | } |
341 | ||
342 | return true; | |
343 | } | |
ceabc520 MV |
344 | |
345 | /*}}}*/ | |
346 | // DPkgPM::DoStdin - Read stdin and pass to slave pty /*{{{*/ | |
347 | // --------------------------------------------------------------------- | |
348 | /* | |
349 | */ | |
350 | void pkgDPkgPM::DoStdin(int master) | |
351 | { | |
aff87a76 MV |
352 | unsigned char input_buf[256] = {0,}; |
353 | ssize_t len = read(0, input_buf, sizeof(input_buf)); | |
9983591d OS |
354 | if (len) |
355 | write(master, input_buf, len); | |
356 | else | |
357 | stdin_is_dev_null = true; | |
ceabc520 | 358 | } |
03e39e59 | 359 | /*}}}*/ |
ceabc520 MV |
360 | // DPkgPM::DoTerminalPty - Read the terminal pty and write log /*{{{*/ |
361 | // --------------------------------------------------------------------- | |
362 | /* | |
363 | * read the terminal pty and write log | |
364 | */ | |
1ba38171 | 365 | void pkgDPkgPM::DoTerminalPty(int master) |
ceabc520 | 366 | { |
aff87a76 | 367 | unsigned char term_buf[1024] = {0,0, }; |
ceabc520 | 368 | |
aff87a76 | 369 | ssize_t len=read(master, term_buf, sizeof(term_buf)); |
7052511e MV |
370 | if(len == -1 && errno == EIO) |
371 | { | |
372 | // this happens when the child is about to exit, we | |
373 | // give it time to actually exit, otherwise we run | |
374 | // into a race | |
375 | usleep(500000); | |
376 | return; | |
377 | } | |
378 | if(len <= 0) | |
955a6ddb | 379 | return; |
955a6ddb | 380 | write(1, term_buf, len); |
8da1f029 MV |
381 | if(term_out) |
382 | fwrite(term_buf, len, sizeof(char), term_out); | |
ceabc520 | 383 | } |
03e39e59 | 384 | /*}}}*/ |
6191b008 MV |
385 | // DPkgPM::ProcessDpkgStatusBuf /*{{{*/ |
386 | // --------------------------------------------------------------------- | |
387 | /* | |
388 | */ | |
09fa2df2 | 389 | void pkgDPkgPM::ProcessDpkgStatusLine(int OutStatusFd, char *line) |
6191b008 | 390 | { |
887f5036 | 391 | bool const Debug = _config->FindB("Debug::pkgDPkgProgressReporting",false); |
09fa2df2 MV |
392 | // the status we output |
393 | ostringstream status; | |
394 | ||
887f5036 | 395 | if (Debug == true) |
09fa2df2 MV |
396 | std::clog << "got from dpkg '" << line << "'" << std::endl; |
397 | ||
398 | ||
399 | /* dpkg sends strings like this: | |
400 | 'status: <pkg>: <pkg qstate>' | |
401 | errors look like this: | |
402 | 'status: /var/cache/apt/archives/krecipes_0.8.1-0ubuntu1_i386.deb : error : trying to overwrite `/usr/share/doc/kde/HTML/en/krecipes/krectip.png', which is also in package krecipes-data | |
403 | and conffile-prompt like this | |
404 | 'status: conffile-prompt: conffile : 'current-conffile' 'new-conffile' useredited distedited | |
fc2d32c0 MV |
405 | |
406 | Newer versions of dpkg sent also: | |
407 | 'processing: install: pkg' | |
408 | 'processing: configure: pkg' | |
409 | 'processing: remove: pkg' | |
887f5036 | 410 | 'processing: purge: pkg' - but for apt is it a ignored "unknown" action |
fc2d32c0 | 411 | 'processing: trigproc: trigger' |
09fa2df2 MV |
412 | |
413 | */ | |
414 | char* list[5]; | |
415 | // dpkg sends multiline error messages sometimes (see | |
416 | // #374195 for a example. we should support this by | |
417 | // either patching dpkg to not send multiline over the | |
418 | // statusfd or by rewriting the code here to deal with | |
419 | // it. for now we just ignore it and not crash | |
420 | TokSplitString(':', line, list, sizeof(list)/sizeof(list[0])); | |
f26fcbc7 | 421 | if( list[0] == NULL || list[1] == NULL || list[2] == NULL) |
09fa2df2 | 422 | { |
887f5036 | 423 | if (Debug == true) |
09fa2df2 MV |
424 | std::clog << "ignoring line: not enough ':'" << std::endl; |
425 | return; | |
426 | } | |
887f5036 DK |
427 | const char* const pkg = list[1]; |
428 | const char* action = _strstrip(list[2]); | |
09fa2df2 | 429 | |
fc2d32c0 MV |
430 | // 'processing' from dpkg looks like |
431 | // 'processing: action: pkg' | |
432 | if(strncmp(list[0], "processing", strlen("processing")) == 0) | |
433 | { | |
434 | char s[200]; | |
887f5036 DK |
435 | const char* const pkg_or_trigger = _strstrip(list[2]); |
436 | action = _strstrip( list[1]); | |
f7dec19f DB |
437 | const std::pair<const char *, const char *> * const iter = |
438 | std::find_if(PackageProcessingOpsBegin, | |
439 | PackageProcessingOpsEnd, | |
440 | MatchProcessingOp(action)); | |
441 | if(iter == PackageProcessingOpsEnd) | |
fc2d32c0 | 442 | { |
887f5036 DK |
443 | if (Debug == true) |
444 | std::clog << "ignoring unknown action: " << action << std::endl; | |
fc2d32c0 MV |
445 | return; |
446 | } | |
f7dec19f | 447 | snprintf(s, sizeof(s), _(iter->second), pkg_or_trigger); |
fc2d32c0 MV |
448 | |
449 | status << "pmstatus:" << pkg_or_trigger | |
450 | << ":" << (PackagesDone/float(PackagesTotal)*100.0) | |
451 | << ":" << s | |
452 | << endl; | |
453 | if(OutStatusFd > 0) | |
454 | write(OutStatusFd, status.str().c_str(), status.str().size()); | |
887f5036 | 455 | if (Debug == true) |
fc2d32c0 MV |
456 | std::clog << "send: '" << status.str() << "'" << endl; |
457 | return; | |
458 | } | |
459 | ||
09fa2df2 MV |
460 | if(strncmp(action,"error",strlen("error")) == 0) |
461 | { | |
462 | status << "pmerror:" << list[1] | |
ff56e980 | 463 | << ":" << (PackagesDone/float(PackagesTotal)*100.0) |
09fa2df2 MV |
464 | << ":" << list[3] |
465 | << endl; | |
466 | if(OutStatusFd > 0) | |
467 | write(OutStatusFd, status.str().c_str(), status.str().size()); | |
887f5036 | 468 | if (Debug == true) |
09fa2df2 MV |
469 | std::clog << "send: '" << status.str() << "'" << endl; |
470 | return; | |
471 | } | |
887f5036 | 472 | else if(strncmp(action,"conffile",strlen("conffile")) == 0) |
09fa2df2 MV |
473 | { |
474 | status << "pmconffile:" << list[1] | |
ff56e980 | 475 | << ":" << (PackagesDone/float(PackagesTotal)*100.0) |
09fa2df2 MV |
476 | << ":" << list[3] |
477 | << endl; | |
478 | if(OutStatusFd > 0) | |
479 | write(OutStatusFd, status.str().c_str(), status.str().size()); | |
887f5036 | 480 | if (Debug == true) |
09fa2df2 MV |
481 | std::clog << "send: '" << status.str() << "'" << endl; |
482 | return; | |
483 | } | |
484 | ||
887f5036 | 485 | vector<struct DpkgState> const &states = PackageOps[pkg]; |
09fa2df2 MV |
486 | const char *next_action = NULL; |
487 | if(PackageOpsDone[pkg] < states.size()) | |
488 | next_action = states[PackageOpsDone[pkg]].state; | |
489 | // check if the package moved to the next dpkg state | |
490 | if(next_action && (strcmp(action, next_action) == 0)) | |
491 | { | |
492 | // only read the translation if there is actually a next | |
493 | // action | |
494 | const char *translation = _(states[PackageOpsDone[pkg]].str); | |
495 | char s[200]; | |
496 | snprintf(s, sizeof(s), translation, pkg); | |
497 | ||
498 | // we moved from one dpkg state to a new one, report that | |
499 | PackageOpsDone[pkg]++; | |
ff56e980 | 500 | PackagesDone++; |
09fa2df2 MV |
501 | // build the status str |
502 | status << "pmstatus:" << pkg | |
ff56e980 | 503 | << ":" << (PackagesDone/float(PackagesTotal)*100.0) |
09fa2df2 MV |
504 | << ":" << s |
505 | << endl; | |
506 | if(OutStatusFd > 0) | |
507 | write(OutStatusFd, status.str().c_str(), status.str().size()); | |
887f5036 | 508 | if (Debug == true) |
09fa2df2 MV |
509 | std::clog << "send: '" << status.str() << "'" << endl; |
510 | } | |
887f5036 | 511 | if (Debug == true) |
09fa2df2 MV |
512 | std::clog << "(parsed from dpkg) pkg: " << pkg |
513 | << " action: " << action << endl; | |
6191b008 | 514 | } |
887f5036 DK |
515 | /*}}}*/ |
516 | // DPkgPM::DoDpkgStatusFd /*{{{*/ | |
6191b008 MV |
517 | // --------------------------------------------------------------------- |
518 | /* | |
519 | */ | |
09fa2df2 | 520 | void pkgDPkgPM::DoDpkgStatusFd(int statusfd, int OutStatusFd) |
6191b008 MV |
521 | { |
522 | char *p, *q; | |
523 | int len; | |
524 | ||
525 | len=read(statusfd, &dpkgbuf[dpkgbuf_pos], sizeof(dpkgbuf)-dpkgbuf_pos); | |
526 | dpkgbuf_pos += len; | |
527 | if(len <= 0) | |
528 | return; | |
ceabc520 | 529 | |
6191b008 MV |
530 | // process line by line if we have a buffer |
531 | p = q = dpkgbuf; | |
532 | while((q=(char*)memchr(p, '\n', dpkgbuf+dpkgbuf_pos-p)) != NULL) | |
533 | { | |
534 | *q = 0; | |
09fa2df2 | 535 | ProcessDpkgStatusLine(OutStatusFd, p); |
6191b008 MV |
536 | p=q+1; // continue with next line |
537 | } | |
538 | ||
539 | // now move the unprocessed bits (after the final \n that is now a 0x0) | |
540 | // to the start and update dpkgbuf_pos | |
541 | p = (char*)memrchr(dpkgbuf, 0, dpkgbuf_pos); | |
542 | if(p == NULL) | |
543 | return; | |
544 | ||
545 | // we are interessted in the first char *after* 0x0 | |
546 | p++; | |
547 | ||
548 | // move the unprocessed tail to the start and update pos | |
549 | memmove(dpkgbuf, p, p-dpkgbuf); | |
550 | dpkgbuf_pos = dpkgbuf+dpkgbuf_pos-p; | |
551 | } | |
552 | /*}}}*/ | |
d7a4ffd6 MV |
553 | // DPkgPM::WriteHistoryTag /*{{{*/ |
554 | void pkgDPkgPM::WriteHistoryTag(string tag, string value) | |
555 | { | |
556 | if (value.size() > 0) | |
557 | { | |
558 | // poor mans rstrip(", ") | |
559 | if (value[value.size()-2] == ',' && value[value.size()-1] == ' ') | |
560 | value.erase(value.size() - 2, 2); | |
561 | fprintf(history_out, "%s: %s\n", tag.c_str(), value.c_str()); | |
562 | } | |
563 | } /*}}}*/ | |
887f5036 | 564 | // DPkgPM::OpenLog /*{{{*/ |
2e1715ea MV |
565 | bool pkgDPkgPM::OpenLog() |
566 | { | |
567 | string logdir = _config->FindDir("Dir::Log"); | |
568 | if(not FileExists(logdir)) | |
569 | return _error->Error(_("Directory '%s' missing"), logdir.c_str()); | |
9169c871 MV |
570 | |
571 | // get current time | |
572 | char timestr[200]; | |
573 | time_t t = time(NULL); | |
574 | struct tm *tmp = localtime(&t); | |
575 | strftime(timestr, sizeof(timestr), "%F %T", tmp); | |
576 | ||
577 | // open terminal log | |
2e1715ea MV |
578 | string logfile_name = flCombine(logdir, |
579 | _config->Find("Dir::Log::Terminal")); | |
580 | if (!logfile_name.empty()) | |
581 | { | |
582 | term_out = fopen(logfile_name.c_str(),"a"); | |
b39c1859 MV |
583 | if (term_out == NULL) |
584 | return _error->WarningE(_("Could not open file '%s'"), logfile_name.c_str()); | |
585 | ||
2e1715ea | 586 | chmod(logfile_name.c_str(), 0600); |
762d7367 | 587 | fprintf(term_out, "\nLog started: %s\n", timestr); |
2e1715ea | 588 | } |
9169c871 MV |
589 | |
590 | // write | |
591 | string history_name = flCombine(logdir, | |
592 | _config->Find("Dir::Log::History")); | |
593 | if (!history_name.empty()) | |
594 | { | |
595 | history_out = fopen(history_name.c_str(),"a"); | |
596 | chmod(history_name.c_str(), 0644); | |
597 | fprintf(history_out, "\nStart-Date: %s\n", timestr); | |
598 | string remove, purge, install, upgrade, downgrade; | |
599 | for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; I++) | |
600 | { | |
d7a4ffd6 MV |
601 | if (Cache[I].NewInstall()) |
602 | install += I.Name() + string(" (") + Cache[I].CandVersion + string("), "); | |
603 | else if (Cache[I].Upgrade()) | |
604 | upgrade += I.Name() + string(" (") + Cache[I].CurVersion + string(", ") + Cache[I].CandVersion + string("), "); | |
9c59aada | 605 | else if (Cache[I].Downgrade()) |
d7a4ffd6 | 606 | downgrade += I.Name() + string(" (") + Cache[I].CurVersion + string(", ") + Cache[I].CandVersion + string("), "); |
9169c871 MV |
607 | else if (Cache[I].Delete()) |
608 | { | |
609 | if ((Cache[I].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge) | |
d7a4ffd6 | 610 | purge += I.Name() + string(" (") + Cache[I].CurVersion + string("), "); |
9169c871 | 611 | else |
d7a4ffd6 | 612 | remove += I.Name() + string(" (") + Cache[I].CurVersion + string("), "); |
9169c871 | 613 | } |
9169c871 | 614 | } |
d7a4ffd6 MV |
615 | WriteHistoryTag("Install", install); |
616 | WriteHistoryTag("Upgrade", upgrade); | |
617 | WriteHistoryTag("Downgrade",downgrade); | |
618 | WriteHistoryTag("Remove",remove); | |
619 | WriteHistoryTag("Purge",purge); | |
06d5520f | 620 | fflush(history_out); |
9169c871 MV |
621 | } |
622 | ||
2e1715ea MV |
623 | return true; |
624 | } | |
887f5036 DK |
625 | /*}}}*/ |
626 | // DPkg::CloseLog /*{{{*/ | |
2e1715ea MV |
627 | bool pkgDPkgPM::CloseLog() |
628 | { | |
9169c871 MV |
629 | char timestr[200]; |
630 | time_t t = time(NULL); | |
631 | struct tm *tmp = localtime(&t); | |
632 | strftime(timestr, sizeof(timestr), "%F %T", tmp); | |
633 | ||
2e1715ea MV |
634 | if(term_out) |
635 | { | |
8398ac36 | 636 | fprintf(term_out, "Log ended: "); |
9169c871 | 637 | fprintf(term_out, "%s", timestr); |
2e1715ea MV |
638 | fprintf(term_out, "\n"); |
639 | fclose(term_out); | |
640 | } | |
641 | term_out = NULL; | |
9169c871 MV |
642 | |
643 | if(history_out) | |
644 | { | |
645 | if (dpkg_error.size() > 0) | |
646 | fprintf(history_out, "Error: %s\n", dpkg_error.c_str()); | |
647 | fprintf(history_out, "End-Date: %s\n", timestr); | |
648 | fclose(history_out); | |
649 | } | |
650 | ||
2e1715ea MV |
651 | return true; |
652 | } | |
887f5036 | 653 | /*}}}*/ |
919e5852 OS |
654 | /*{{{*/ |
655 | // This implements a racy version of pselect for those architectures | |
656 | // that don't have a working implementation. | |
657 | // FIXME: Probably can be removed on Lenny+1 | |
658 | static int racy_pselect(int nfds, fd_set *readfds, fd_set *writefds, | |
659 | fd_set *exceptfds, const struct timespec *timeout, | |
660 | const sigset_t *sigmask) | |
661 | { | |
662 | sigset_t origmask; | |
663 | struct timeval tv; | |
664 | int retval; | |
665 | ||
f6b37f38 OS |
666 | tv.tv_sec = timeout->tv_sec; |
667 | tv.tv_usec = timeout->tv_nsec/1000; | |
919e5852 | 668 | |
f6b37f38 | 669 | sigprocmask(SIG_SETMASK, sigmask, &origmask); |
919e5852 OS |
670 | retval = select(nfds, readfds, writefds, exceptfds, &tv); |
671 | sigprocmask(SIG_SETMASK, &origmask, 0); | |
672 | return retval; | |
673 | } | |
674 | /*}}}*/ | |
03e39e59 AL |
675 | // DPkgPM::Go - Run the sequence /*{{{*/ |
676 | // --------------------------------------------------------------------- | |
75ef8f14 MV |
677 | /* This globs the operations and calls dpkg |
678 | * | |
679 | * If it is called with "OutStatusFd" set to a valid file descriptor | |
680 | * apt will report the install progress over this fd. It maps the | |
681 | * dpkg states a package goes through to human readable (and i10n-able) | |
682 | * names and calculates a percentage for each step. | |
683 | */ | |
684 | bool pkgDPkgPM::Go(int OutStatusFd) | |
03e39e59 | 685 | { |
17745b02 MV |
686 | fd_set rfds; |
687 | struct timespec tv; | |
688 | sigset_t sigmask; | |
689 | sigset_t original_sigmask; | |
690 | ||
887f5036 DK |
691 | unsigned int const MaxArgs = _config->FindI("Dpkg::MaxArgs",8*1024); |
692 | unsigned int const MaxArgBytes = _config->FindI("Dpkg::MaxArgBytes",32*1024); | |
5e312de7 | 693 | bool const NoTriggers = _config->FindB("DPkg::NoTriggers", false); |
aff4e2f1 | 694 | |
6dd55be7 AL |
695 | if (RunScripts("DPkg::Pre-Invoke") == false) |
696 | return false; | |
db0c350f AL |
697 | |
698 | if (RunScriptsWithPkgs("DPkg::Pre-Install-Pkgs") == false) | |
699 | return false; | |
fc2d32c0 | 700 | |
3e9c4f70 DK |
701 | // support subpressing of triggers processing for special |
702 | // cases like d-i that runs the triggers handling manually | |
5e312de7 | 703 | bool const SmartConf = (_config->Find("PackageManager::Configure", "all") != "all"); |
5c23dbcc | 704 | bool const TriggersPending = _config->FindB("DPkg::TriggersPending", false); |
5e312de7 DK |
705 | if (_config->FindB("DPkg::ConfigurePending", SmartConf) == true) |
706 | List.push_back(Item(Item::ConfigurePending, PkgIterator())); | |
3e9c4f70 | 707 | |
75ef8f14 MV |
708 | // map the dpkg states to the operations that are performed |
709 | // (this is sorted in the same way as Item::Ops) | |
9d06bc80 | 710 | static const struct DpkgState DpkgStatesOpMap[][7] = { |
75ef8f14 MV |
711 | // Install operation |
712 | { | |
21e1008e MV |
713 | {"half-installed", N_("Preparing %s")}, |
714 | {"unpacked", N_("Unpacking %s") }, | |
75ef8f14 MV |
715 | {NULL, NULL} |
716 | }, | |
717 | // Configure operation | |
718 | { | |
21e1008e MV |
719 | {"unpacked",N_("Preparing to configure %s") }, |
720 | {"half-configured", N_("Configuring %s") }, | |
721 | { "installed", N_("Installed %s")}, | |
75ef8f14 MV |
722 | {NULL, NULL} |
723 | }, | |
724 | // Remove operation | |
725 | { | |
21e1008e MV |
726 | {"half-configured", N_("Preparing for removal of %s")}, |
727 | {"half-installed", N_("Removing %s")}, | |
728 | {"config-files", N_("Removed %s")}, | |
75ef8f14 MV |
729 | {NULL, NULL} |
730 | }, | |
731 | // Purge operation | |
732 | { | |
21e1008e MV |
733 | {"config-files", N_("Preparing to completely remove %s")}, |
734 | {"not-installed", N_("Completely removed %s")}, | |
75ef8f14 MV |
735 | {NULL, NULL} |
736 | }, | |
737 | }; | |
db0c350f | 738 | |
75ef8f14 MV |
739 | // init the PackageOps map, go over the list of packages that |
740 | // that will be [installed|configured|removed|purged] and add | |
741 | // them to the PackageOps map (the dpkg states it goes through) | |
742 | // and the PackageOpsTranslations (human readable strings) | |
887f5036 | 743 | for (vector<Item>::const_iterator I = List.begin(); I != List.end();I++) |
75ef8f14 | 744 | { |
3e9c4f70 DK |
745 | if((*I).Pkg.end() == true) |
746 | continue; | |
747 | ||
887f5036 | 748 | string const name = (*I).Pkg.Name(); |
75ef8f14 MV |
749 | PackageOpsDone[name] = 0; |
750 | for(int i=0; (DpkgStatesOpMap[(*I).Op][i]).state != NULL; i++) | |
751 | { | |
752 | PackageOps[name].push_back(DpkgStatesOpMap[(*I).Op][i]); | |
ff56e980 | 753 | PackagesTotal++; |
75ef8f14 | 754 | } |
887f5036 | 755 | } |
75ef8f14 | 756 | |
9983591d OS |
757 | stdin_is_dev_null = false; |
758 | ||
ff56e980 | 759 | // create log |
2e1715ea | 760 | OpenLog(); |
ff56e980 | 761 | |
75ef8f14 | 762 | // this loop is runs once per operation |
887f5036 | 763 | for (vector<Item>::const_iterator I = List.begin(); I != List.end();) |
03e39e59 | 764 | { |
5c23dbcc | 765 | // Do all actions with the same Op in one run |
887f5036 | 766 | vector<Item>::const_iterator J = I; |
5c23dbcc DK |
767 | if (TriggersPending == true) |
768 | for (; J != List.end(); J++) | |
769 | { | |
770 | if (J->Op == I->Op) | |
771 | continue; | |
772 | if (J->Op != Item::TriggersPending) | |
773 | break; | |
774 | vector<Item>::const_iterator T = J + 1; | |
775 | if (T != List.end() && T->Op == I->Op) | |
776 | continue; | |
777 | break; | |
778 | } | |
779 | else | |
780 | for (; J != List.end() && J->Op == I->Op; J++) | |
781 | /* nothing */; | |
30e1eab5 | 782 | |
03e39e59 | 783 | // Generate the argument list |
aff4e2f1 | 784 | const char *Args[MaxArgs + 50]; |
599d6ad5 MV |
785 | |
786 | // Now check if we are within the MaxArgs limit | |
787 | // | |
788 | // this code below is problematic, because it may happen that | |
789 | // the argument list is split in a way that A depends on B | |
790 | // and they are in the same "--configure A B" run | |
791 | // - with the split they may now be configured in different | |
792 | // runs | |
aff4e2f1 AL |
793 | if (J - I > (signed)MaxArgs) |
794 | J = I + MaxArgs; | |
03e39e59 | 795 | |
30e1eab5 AL |
796 | unsigned int n = 0; |
797 | unsigned long Size = 0; | |
887f5036 | 798 | string const Tmp = _config->Find("Dir::Bin::dpkg","dpkg"); |
50914ffa | 799 | Args[n++] = Tmp.c_str(); |
30e1eab5 | 800 | Size += strlen(Args[n-1]); |
03e39e59 | 801 | |
6dd55be7 AL |
802 | // Stick in any custom dpkg options |
803 | Configuration::Item const *Opts = _config->Tree("DPkg::Options"); | |
804 | if (Opts != 0) | |
805 | { | |
806 | Opts = Opts->Child; | |
807 | for (; Opts != 0; Opts = Opts->Next) | |
808 | { | |
809 | if (Opts->Value.empty() == true) | |
810 | continue; | |
811 | Args[n++] = Opts->Value.c_str(); | |
812 | Size += Opts->Value.length(); | |
813 | } | |
814 | } | |
815 | ||
007dc9e0 | 816 | char status_fd_buf[20]; |
75ef8f14 MV |
817 | int fd[2]; |
818 | pipe(fd); | |
819 | ||
820 | Args[n++] = "--status-fd"; | |
821 | Size += strlen(Args[n-1]); | |
822 | snprintf(status_fd_buf,sizeof(status_fd_buf),"%i", fd[1]); | |
823 | Args[n++] = status_fd_buf; | |
824 | Size += strlen(Args[n-1]); | |
007dc9e0 | 825 | |
03e39e59 AL |
826 | switch (I->Op) |
827 | { | |
828 | case Item::Remove: | |
829 | Args[n++] = "--force-depends"; | |
30e1eab5 | 830 | Size += strlen(Args[n-1]); |
03e39e59 | 831 | Args[n++] = "--force-remove-essential"; |
30e1eab5 | 832 | Size += strlen(Args[n-1]); |
03e39e59 | 833 | Args[n++] = "--remove"; |
30e1eab5 | 834 | Size += strlen(Args[n-1]); |
03e39e59 AL |
835 | break; |
836 | ||
fc4b5c9f AL |
837 | case Item::Purge: |
838 | Args[n++] = "--force-depends"; | |
839 | Size += strlen(Args[n-1]); | |
840 | Args[n++] = "--force-remove-essential"; | |
841 | Size += strlen(Args[n-1]); | |
842 | Args[n++] = "--purge"; | |
843 | Size += strlen(Args[n-1]); | |
844 | break; | |
845 | ||
03e39e59 AL |
846 | case Item::Configure: |
847 | Args[n++] = "--configure"; | |
30e1eab5 | 848 | Size += strlen(Args[n-1]); |
03e39e59 | 849 | break; |
3e9c4f70 DK |
850 | |
851 | case Item::ConfigurePending: | |
852 | Args[n++] = "--configure"; | |
853 | Size += strlen(Args[n-1]); | |
854 | Args[n++] = "--pending"; | |
855 | Size += strlen(Args[n-1]); | |
856 | break; | |
857 | ||
5e312de7 DK |
858 | case Item::TriggersPending: |
859 | Args[n++] = "--triggers-only"; | |
860 | Size += strlen(Args[n-1]); | |
861 | Args[n++] = "--pending"; | |
862 | Size += strlen(Args[n-1]); | |
863 | break; | |
864 | ||
03e39e59 AL |
865 | case Item::Install: |
866 | Args[n++] = "--unpack"; | |
30e1eab5 | 867 | Size += strlen(Args[n-1]); |
857a1d4a MV |
868 | Args[n++] = "--auto-deconfigure"; |
869 | Size += strlen(Args[n-1]); | |
03e39e59 AL |
870 | break; |
871 | } | |
3e9c4f70 | 872 | |
5e312de7 | 873 | if (NoTriggers == true && I->Op != Item::TriggersPending && |
d5081aee | 874 | I->Op != Item::ConfigurePending) |
3e9c4f70 DK |
875 | { |
876 | Args[n++] = "--no-triggers"; | |
877 | Size += strlen(Args[n-1]); | |
878 | } | |
879 | ||
03e39e59 AL |
880 | // Write in the file or package names |
881 | if (I->Op == Item::Install) | |
30e1eab5 | 882 | { |
aff4e2f1 | 883 | for (;I != J && Size < MaxArgBytes; I++) |
30e1eab5 | 884 | { |
cf544e14 AL |
885 | if (I->File[0] != '/') |
886 | return _error->Error("Internal Error, Pathname to install is not absolute '%s'",I->File.c_str()); | |
03e39e59 | 887 | Args[n++] = I->File.c_str(); |
30e1eab5 AL |
888 | Size += strlen(Args[n-1]); |
889 | } | |
890 | } | |
03e39e59 | 891 | else |
30e1eab5 | 892 | { |
aff4e2f1 | 893 | for (;I != J && Size < MaxArgBytes; I++) |
30e1eab5 | 894 | { |
3e9c4f70 DK |
895 | if((*I).Pkg.end() == true) |
896 | continue; | |
03e39e59 | 897 | Args[n++] = I->Pkg.Name(); |
30e1eab5 AL |
898 | Size += strlen(Args[n-1]); |
899 | } | |
900 | } | |
03e39e59 | 901 | Args[n] = 0; |
30e1eab5 AL |
902 | J = I; |
903 | ||
904 | if (_config->FindB("Debug::pkgDPkgPM",false) == true) | |
905 | { | |
906 | for (unsigned int k = 0; k != n; k++) | |
907 | clog << Args[k] << ' '; | |
908 | clog << endl; | |
909 | continue; | |
910 | } | |
03e39e59 | 911 | |
03e39e59 AL |
912 | cout << flush; |
913 | clog << flush; | |
914 | cerr << flush; | |
915 | ||
916 | /* Mask off sig int/quit. We do this because dpkg also does when | |
917 | it forks scripts. What happens is that when you hit ctrl-c it sends | |
918 | it to all processes in the group. Since dpkg ignores the signal | |
919 | it doesn't die but we do! So we must also ignore it */ | |
7f9a6360 AL |
920 | sighandler_t old_SIGQUIT = signal(SIGQUIT,SIG_IGN); |
921 | sighandler_t old_SIGINT = signal(SIGINT,SIG_IGN); | |
d8cb4aa4 | 922 | |
73e598c3 MV |
923 | // ignore SIGHUP as well (debian #463030) |
924 | sighandler_t old_SIGHUP = signal(SIGHUP,SIG_IGN); | |
925 | ||
d8cb4aa4 MV |
926 | struct termios tt; |
927 | struct winsize win; | |
4e550036 MV |
928 | int master = -1; |
929 | int slave = -1; | |
d8cb4aa4 | 930 | |
4e550036 MV |
931 | // if tcgetattr does not return zero there was a error |
932 | // and we do not do any pty magic | |
933 | if (tcgetattr(0, &tt) == 0) | |
090c6566 | 934 | { |
4e550036 MV |
935 | ioctl(0, TIOCGWINSZ, (char *)&win); |
936 | if (openpty(&master, &slave, NULL, &tt, &win) < 0) | |
937 | { | |
938 | const char *s = _("Can not write log, openpty() " | |
939 | "failed (/dev/pts not mounted?)\n"); | |
940 | fprintf(stderr, "%s",s); | |
6847d275 MV |
941 | if(term_out) |
942 | fprintf(term_out, "%s",s); | |
4e550036 MV |
943 | master = slave = -1; |
944 | } else { | |
945 | struct termios rtt; | |
946 | rtt = tt; | |
947 | cfmakeraw(&rtt); | |
948 | rtt.c_lflag &= ~ECHO; | |
4d7ac88c | 949 | rtt.c_lflag |= ISIG; |
4e550036 MV |
950 | // block SIGTTOU during tcsetattr to prevent a hang if |
951 | // the process is a member of the background process group | |
952 | // http://www.opengroup.org/onlinepubs/000095399/functions/tcsetattr.html | |
953 | sigemptyset(&sigmask); | |
954 | sigaddset(&sigmask, SIGTTOU); | |
955 | sigprocmask(SIG_BLOCK,&sigmask, &original_sigmask); | |
956 | tcsetattr(0, TCSAFLUSH, &rtt); | |
957 | sigprocmask(SIG_SETMASK, &original_sigmask, 0); | |
958 | } | |
d8cb4aa4 MV |
959 | } |
960 | ||
75ef8f14 | 961 | // Fork dpkg |
007dc9e0 | 962 | pid_t Child; |
75ef8f14 | 963 | _config->Set("APT::Keep-Fds::",fd[1]); |
ccd8e28f MV |
964 | // send status information that we are about to fork dpkg |
965 | if(OutStatusFd > 0) { | |
966 | ostringstream status; | |
967 | status << "pmstatus:dpkg-exec:" | |
968 | << (PackagesDone/float(PackagesTotal)*100.0) | |
969 | << ":" << _("Running dpkg") | |
970 | << endl; | |
971 | write(OutStatusFd, status.str().c_str(), status.str().size()); | |
972 | } | |
75ef8f14 | 973 | Child = ExecFork(); |
6dd55be7 | 974 | |
03e39e59 AL |
975 | // This is the child |
976 | if (Child == 0) | |
977 | { | |
a4cf3665 MV |
978 | if(slave >= 0 && master >= 0) |
979 | { | |
980 | setsid(); | |
981 | ioctl(slave, TIOCSCTTY, 0); | |
982 | close(master); | |
983 | dup2(slave, 0); | |
984 | dup2(slave, 1); | |
985 | dup2(slave, 2); | |
986 | close(slave); | |
987 | } | |
75ef8f14 | 988 | close(fd[0]); // close the read end of the pipe |
d8cb4aa4 | 989 | |
4b7cfe96 MV |
990 | if (_config->FindDir("DPkg::Chroot-Directory","/") != "/") |
991 | { | |
992 | std::cerr << "Chrooting into " | |
993 | << _config->FindDir("DPkg::Chroot-Directory") | |
994 | << std::endl; | |
995 | if (chroot(_config->FindDir("DPkg::Chroot-Directory","/").c_str()) != 0) | |
996 | _exit(100); | |
997 | } | |
998 | ||
cf544e14 | 999 | if (chdir(_config->FindDir("DPkg::Run-Directory","/").c_str()) != 0) |
0dbb95d8 | 1000 | _exit(100); |
03e39e59 | 1001 | |
421ff807 | 1002 | if (_config->FindB("DPkg::FlushSTDIN",true) == true && isatty(STDIN_FILENO)) |
8b5fe26c AL |
1003 | { |
1004 | int Flags,dummy; | |
1005 | if ((Flags = fcntl(STDIN_FILENO,F_GETFL,dummy)) < 0) | |
1006 | _exit(100); | |
1007 | ||
1008 | // Discard everything in stdin before forking dpkg | |
1009 | if (fcntl(STDIN_FILENO,F_SETFL,Flags | O_NONBLOCK) < 0) | |
1010 | _exit(100); | |
1011 | ||
1012 | while (read(STDIN_FILENO,&dummy,1) == 1); | |
1013 | ||
1014 | if (fcntl(STDIN_FILENO,F_SETFL,Flags & (~(long)O_NONBLOCK)) < 0) | |
1015 | _exit(100); | |
1016 | } | |
d8cb4aa4 | 1017 | |
03e39e59 AL |
1018 | /* No Job Control Stop Env is a magic dpkg var that prevents it |
1019 | from using sigstop */ | |
71afbdb5 | 1020 | putenv((char *)"DPKG_NO_TSTP=yes"); |
d568ed2d | 1021 | execvp(Args[0],(char **)Args); |
03e39e59 | 1022 | cerr << "Could not exec dpkg!" << endl; |
0dbb95d8 | 1023 | _exit(100); |
03e39e59 AL |
1024 | } |
1025 | ||
cebe0287 MV |
1026 | // apply ionice |
1027 | if (_config->FindB("DPkg::UseIoNice", false) == true) | |
1028 | ionice(Child); | |
1029 | ||
75ef8f14 MV |
1030 | // clear the Keep-Fd again |
1031 | _config->Clear("APT::Keep-Fds",fd[1]); | |
1032 | ||
03e39e59 AL |
1033 | // Wait for dpkg |
1034 | int Status = 0; | |
75ef8f14 MV |
1035 | |
1036 | // we read from dpkg here | |
887f5036 | 1037 | int const _dpkgin = fd[0]; |
75ef8f14 MV |
1038 | close(fd[1]); // close the write end of the pipe |
1039 | ||
a4cf3665 MV |
1040 | if(slave > 0) |
1041 | close(slave); | |
6191b008 | 1042 | |
97efd303 | 1043 | // setups fds |
7052511e MV |
1044 | sigemptyset(&sigmask); |
1045 | sigprocmask(SIG_BLOCK,&sigmask,&original_sigmask); | |
1046 | ||
887f5036 DK |
1047 | // the result of the waitpid call |
1048 | int res; | |
090c6566 | 1049 | int select_ret; |
75ef8f14 MV |
1050 | while ((res=waitpid(Child,&Status, WNOHANG)) != Child) { |
1051 | if(res < 0) { | |
1052 | // FIXME: move this to a function or something, looks ugly here | |
1053 | // error handling, waitpid returned -1 | |
1054 | if (errno == EINTR) | |
1055 | continue; | |
1056 | RunScripts("DPkg::Post-Invoke"); | |
1057 | ||
1058 | // Restore sig int/quit | |
1059 | signal(SIGQUIT,old_SIGQUIT); | |
1060 | signal(SIGINT,old_SIGINT); | |
e306ec47 | 1061 | signal(SIGHUP,old_SIGHUP); |
75ef8f14 MV |
1062 | return _error->Errno("waitpid","Couldn't wait for subprocess"); |
1063 | } | |
d8cb4aa4 MV |
1064 | |
1065 | // wait for input or output here | |
955a6ddb | 1066 | FD_ZERO(&rfds); |
897165af | 1067 | if (master >= 0 && !stdin_is_dev_null) |
9983591d | 1068 | FD_SET(0, &rfds); |
955a6ddb | 1069 | FD_SET(_dpkgin, &rfds); |
a4cf3665 MV |
1070 | if(master >= 0) |
1071 | FD_SET(master, &rfds); | |
090c6566 | 1072 | tv.tv_sec = 1; |
7052511e MV |
1073 | tv.tv_nsec = 0; |
1074 | select_ret = pselect(max(master, _dpkgin)+1, &rfds, NULL, NULL, | |
1075 | &tv, &original_sigmask); | |
919e5852 OS |
1076 | if (select_ret < 0 && (errno == EINVAL || errno == ENOSYS)) |
1077 | select_ret = racy_pselect(max(master, _dpkgin)+1, &rfds, NULL, | |
1078 | NULL, &tv, &original_sigmask); | |
da50ba30 MV |
1079 | if (select_ret == 0) |
1080 | continue; | |
1081 | else if (select_ret < 0 && errno == EINTR) | |
1082 | continue; | |
1083 | else if (select_ret < 0) | |
1084 | { | |
1085 | perror("select() returned error"); | |
1086 | continue; | |
1087 | } | |
1088 | ||
a4cf3665 | 1089 | if(master >= 0 && FD_ISSET(master, &rfds)) |
1ba38171 | 1090 | DoTerminalPty(master); |
a4cf3665 | 1091 | if(master >= 0 && FD_ISSET(0, &rfds)) |
955a6ddb | 1092 | DoStdin(master); |
955a6ddb | 1093 | if(FD_ISSET(_dpkgin, &rfds)) |
09fa2df2 | 1094 | DoDpkgStatusFd(_dpkgin, OutStatusFd); |
03e39e59 | 1095 | } |
75ef8f14 | 1096 | close(_dpkgin); |
03e39e59 AL |
1097 | |
1098 | // Restore sig int/quit | |
7f9a6360 AL |
1099 | signal(SIGQUIT,old_SIGQUIT); |
1100 | signal(SIGINT,old_SIGINT); | |
d9ec0fac | 1101 | signal(SIGHUP,old_SIGHUP); |
d8cb4aa4 | 1102 | |
477b5d6c MV |
1103 | if(master >= 0) |
1104 | { | |
a4cf3665 | 1105 | tcsetattr(0, TCSAFLUSH, &tt); |
477b5d6c MV |
1106 | close(master); |
1107 | } | |
6dd55be7 AL |
1108 | |
1109 | // Check for an error code. | |
1110 | if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0) | |
1111 | { | |
c70496f9 MV |
1112 | // if it was set to "keep-dpkg-runing" then we won't return |
1113 | // here but keep the loop going and just report it as a error | |
1114 | // for later | |
887f5036 | 1115 | bool const stopOnError = _config->FindB("Dpkg::StopOnError",true); |
f956efb4 | 1116 | |
c70496f9 MV |
1117 | if(stopOnError) |
1118 | RunScripts("DPkg::Post-Invoke"); | |
1119 | ||
1120 | if (WIFSIGNALED(Status) != 0 && WTERMSIG(Status) == SIGSEGV) | |
9169c871 | 1121 | strprintf(dpkg_error, "Sub-process %s received a segmentation fault.",Args[0]); |
c70496f9 | 1122 | else if (WIFEXITED(Status) != 0) |
9169c871 | 1123 | strprintf(dpkg_error, "Sub-process %s returned an error code (%u)",Args[0],WEXITSTATUS(Status)); |
c70496f9 | 1124 | else |
9169c871 MV |
1125 | strprintf(dpkg_error, "Sub-process %s exited unexpectedly",Args[0]); |
1126 | ||
1127 | if(dpkg_error.size() > 0) | |
1128 | _error->Error(dpkg_error.c_str()); | |
c70496f9 | 1129 | |
ff56e980 MV |
1130 | if(stopOnError) |
1131 | { | |
2e1715ea | 1132 | CloseLog(); |
c70496f9 | 1133 | return false; |
ff56e980 | 1134 | } |
6dd55be7 | 1135 | } |
03e39e59 | 1136 | } |
2e1715ea | 1137 | CloseLog(); |
6dd55be7 AL |
1138 | |
1139 | if (RunScripts("DPkg::Post-Invoke") == false) | |
1140 | return false; | |
b462d75a MV |
1141 | |
1142 | Cache.writeStateFile(NULL); | |
03e39e59 AL |
1143 | return true; |
1144 | } | |
1145 | /*}}}*/ | |
281daf46 AL |
1146 | // pkgDpkgPM::Reset - Dump the contents of the command list /*{{{*/ |
1147 | // --------------------------------------------------------------------- | |
1148 | /* */ | |
1149 | void pkgDPkgPM::Reset() | |
1150 | { | |
1151 | List.erase(List.begin(),List.end()); | |
1152 | } | |
1153 | /*}}}*/ |