]> git.saurik.com Git - apt.git/blob - apt-pkg/deb/dpkgpm.cc
projects / apt.git / blob
? search:


14333c3e70305641755d9e52ef1b79df5b7daa6e
[apt.git] / apt-pkg / deb / dpkgpm.cc
1 // -*- mode: cpp; mode: fold -*-
2 // Description /*{{{*/
3 // $Id: dpkgpm.cc,v 1.28 2004/01/27 02:25:01 mdz Exp $
4 /* ######################################################################
5
6 DPKG Package Manager - Provide an interface to dpkg
7
8 ##################################################################### */
9 /*}}}*/
10 // Includes /*{{{*/
11 #include <config.h>
12
13 #include <apt-pkg/dpkgpm.h>
14 #include <apt-pkg/error.h>
15 #include <apt-pkg/configuration.h>
16 #include <apt-pkg/depcache.h>
17 #include <apt-pkg/pkgrecords.h>
18 #include <apt-pkg/strutl.h>
19 #include <apt-pkg/fileutl.h>
20 #include <apt-pkg/cachefile.h>
21 #include <apt-pkg/packagemanager.h>
22 #include <apt-pkg/install-progress.h>
23
24 #include <unistd.h>
25 #include <stdlib.h>
26 #include <fcntl.h>
27 #include <sys/select.h>
28 #include <sys/stat.h>
29 #include <sys/types.h>
30 #include <sys/wait.h>
31 #include <signal.h>
32 #include <errno.h>
33 #include <string.h>
34 #include <stdio.h>
35 #include <string.h>
36 #include <algorithm>
37 #include <sstream>
38 #include <map>
39 #include <pwd.h>
40 #include <grp.h>
41 #include <iomanip>
42
43 #include <termios.h>
44 #include <unistd.h>
45 #include <sys/ioctl.h>
46 #include <pty.h>
47
48 #include <apti18n.h>
49 /*}}}*/
50
51 using namespace std;
52
53 class pkgDPkgPMPrivate
54 {
55 public:
56 pkgDPkgPMPrivate() : stdin_is_dev_null(false), dpkgbuf_pos(0),
57 term_out(NULL), history_out(NULL),
58 progress(NULL), master(-1), slave(-1)
59 {
60 dpkgbuf[0] = '\0';
61 }
62 ~pkgDPkgPMPrivate()
63 {
64 }
65 bool stdin_is_dev_null;
66 // the buffer we use for the dpkg status-fd reading
67 char dpkgbuf[1024];
68 int dpkgbuf_pos;
69 FILE *term_out;
70 FILE *history_out;
71 string dpkg_error;
72 APT::Progress::PackageManager *progress;
73
74 // pty stuff
75 struct termios tt;
76 int master;
77 int slave;
78
79 // signals
80 sigset_t sigmask;
81 sigset_t original_sigmask;
82
83 };
84
85 namespace
86 {
87 // Maps the dpkg "processing" info to human readable names. Entry 0
88 // of each array is the key, entry 1 is the value.
89 const std::pair<const char *, const char *> PackageProcessingOps[] = {
90 std::make_pair("install", N_("Installing %s")),
91 std::make_pair("configure", N_("Configuring %s")),
92 std::make_pair("remove", N_("Removing %s")),
93 std::make_pair("purge", N_("Completely removing %s")),
94 std::make_pair("disappear", N_("Noting disappearance of %s")),
95 std::make_pair("trigproc", N_("Running post-installation trigger %s"))
96 };
97
98 const std::pair<const char *, const char *> * const PackageProcessingOpsBegin = PackageProcessingOps;
99 const std::pair<const char *, const char *> * const PackageProcessingOpsEnd = PackageProcessingOps + sizeof(PackageProcessingOps) / sizeof(PackageProcessingOps[0]);
100
101 // Predicate to test whether an entry in the PackageProcessingOps
102 // array matches a string.
103 class MatchProcessingOp
104 {
105 const char *target;
106
107 public:
108 MatchProcessingOp(const char *the_target)
109 : target(the_target)
110 {
111 }
112
113 bool operator()(const std::pair<const char *, const char *> &pair) const
114 {
115 return strcmp(pair.first, target) == 0;
116 }
117 };
118 }
119
120 /* helper function to ionice the given PID
121
122 there is no C header for ionice yet - just the syscall interface
123 so we use the binary from util-linux
124 */
125 static bool
126 ionice(int PID)
127 {
128 if (!FileExists("/usr/bin/ionice"))
129 return false;
130 pid_t Process = ExecFork();
131 if (Process == 0)
132 {
133 char buf[32];
134 snprintf(buf, sizeof(buf), "-p%d", PID);
135 const char *Args[4];
136 Args[0] = "/usr/bin/ionice";
137 Args[1] = "-c3";
138 Args[2] = buf;
139 Args[3] = 0;
140 execv(Args[0], (char **)Args);
141 }
142 return ExecWait(Process, "ionice");
143 }
144
145 static std::string getDpkgExecutable()
146 {
147 string Tmp = _config->Find("Dir::Bin::dpkg","dpkg");
148 string const dpkgChrootDir = _config->FindDir("DPkg::Chroot-Directory", "/");
149 size_t dpkgChrootLen = dpkgChrootDir.length();
150 if (dpkgChrootDir != "/" && Tmp.find(dpkgChrootDir) == 0)
151 {
152 if (dpkgChrootDir[dpkgChrootLen - 1] == '/')
153 --dpkgChrootLen;
154 Tmp = Tmp.substr(dpkgChrootLen);
155 }
156 return Tmp;
157 }
158
159 // dpkgChrootDirectory - chrooting for dpkg if needed /*{{{*/
160 static void dpkgChrootDirectory()
161 {
162 std::string const chrootDir = _config->FindDir("DPkg::Chroot-Directory");
163 if (chrootDir == "/")
164 return;
165 std::cerr << "Chrooting into " << chrootDir << std::endl;
166 if (chroot(chrootDir.c_str()) != 0)
167 _exit(100);
168 if (chdir("/") != 0)
169 _exit(100);
170 }
171 /*}}}*/
172
173
174 // FindNowVersion - Helper to find a Version in "now" state /*{{{*/
175 // ---------------------------------------------------------------------
176 /* This is helpful when a package is no longer installed but has residual
177 * config files
178 */
179 static
180 pkgCache::VerIterator FindNowVersion(const pkgCache::PkgIterator &Pkg)
181 {
182 pkgCache::VerIterator Ver;
183 for (Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
184 {
185 pkgCache::VerFileIterator Vf = Ver.FileList();
186 pkgCache::PkgFileIterator F = Vf.File();
187 for (F = Vf.File(); F.end() == false; ++F)
188 {
189 if (F && F.Archive())
190 {
191 if (strcmp(F.Archive(), "now"))
192 return Ver;
193 }
194 }
195 }
196 return Ver;
197 }
198 /*}}}*/
199
200 // DPkgPM::pkgDPkgPM - Constructor /*{{{*/
201 // ---------------------------------------------------------------------
202 /* */
203 pkgDPkgPM::pkgDPkgPM(pkgDepCache *Cache)
204 : pkgPackageManager(Cache), pkgFailures(0), PackagesDone(0), PackagesTotal(0)
205 {
206 d = new pkgDPkgPMPrivate();
207 }
208 /*}}}*/
209 // DPkgPM::pkgDPkgPM - Destructor /*{{{*/
210 // ---------------------------------------------------------------------
211 /* */
212 pkgDPkgPM::~pkgDPkgPM()
213 {
214 delete d;
215 }
216 /*}}}*/
217 // DPkgPM::Install - Install a package /*{{{*/
218 // ---------------------------------------------------------------------
219 /* Add an install operation to the sequence list */
220 bool pkgDPkgPM::Install(PkgIterator Pkg,string File)
221 {
222 if (File.empty() == true || Pkg.end() == true)
223 return _error->Error("Internal Error, No file name for %s",Pkg.FullName().c_str());
224
225 // If the filename string begins with DPkg::Chroot-Directory, return the
226 // substr that is within the chroot so dpkg can access it.
227 string const chrootdir = _config->FindDir("DPkg::Chroot-Directory","/");
228 if (chrootdir != "/" && File.find(chrootdir) == 0)
229 {
230 size_t len = chrootdir.length();
231 if (chrootdir.at(len - 1) == '/')
232 len--;
233 List.push_back(Item(Item::Install,Pkg,File.substr(len)));
234 }
235 else
236 List.push_back(Item(Item::Install,Pkg,File));
237
238 return true;
239 }
240 /*}}}*/
241 // DPkgPM::Configure - Configure a package /*{{{*/
242 // ---------------------------------------------------------------------
243 /* Add a configure operation to the sequence list */
244 bool pkgDPkgPM::Configure(PkgIterator Pkg)
245 {
246 if (Pkg.end() == true)
247 return false;
248
249 List.push_back(Item(Item::Configure, Pkg));
250
251 // Use triggers for config calls if we configure "smart"
252 // as otherwise Pre-Depends will not be satisfied, see #526774
253 if (_config->FindB("DPkg::TriggersPending", false) == true)
254 List.push_back(Item(Item::TriggersPending, PkgIterator()));
255
256 return true;
257 }
258 /*}}}*/
259 // DPkgPM::Remove - Remove a package /*{{{*/
260 // ---------------------------------------------------------------------
261 /* Add a remove operation to the sequence list */
262 bool pkgDPkgPM::Remove(PkgIterator Pkg,bool Purge)
263 {
264 if (Pkg.end() == true)
265 return false;
266
267 if (Purge == true)
268 List.push_back(Item(Item::Purge,Pkg));
269 else
270 List.push_back(Item(Item::Remove,Pkg));
271 return true;
272 }
273 /*}}}*/
274 // DPkgPM::SendPkgInfo - Send info for install-pkgs hook /*{{{*/
275 // ---------------------------------------------------------------------
276 /* This is part of the helper script communication interface, it sends
277 very complete information down to the other end of the pipe.*/
278 bool pkgDPkgPM::SendV2Pkgs(FILE *F)
279 {
280 return SendPkgsInfo(F, 2);
281 }
282 bool pkgDPkgPM::SendPkgsInfo(FILE * const F, unsigned int const &Version)
283 {
284 // This version of APT supports only v3, so don't sent higher versions
285 if (Version <= 3)
286 fprintf(F,"VERSION %u\n", Version);
287 else
288 fprintf(F,"VERSION 3\n");
289
290 /* Write out all of the configuration directives by walking the
291 configuration tree */
292 const Configuration::Item *Top = _config->Tree(0);
293 for (; Top != 0;)
294 {
295 if (Top->Value.empty() == false)
296 {
297 fprintf(F,"%s=%s\n",
298 QuoteString(Top->FullTag(),"=\"\n").c_str(),
299 QuoteString(Top->Value,"\n").c_str());
300 }
301
302 if (Top->Child != 0)
303 {
304 Top = Top->Child;
305 continue;
306 }
307
308 while (Top != 0 && Top->Next == 0)
309 Top = Top->Parent;
310 if (Top != 0)
311 Top = Top->Next;
312 }
313 fprintf(F,"\n");
314
315 // Write out the package actions in order.
316 for (vector<Item>::iterator I = List.begin(); I != List.end(); ++I)
317 {
318 if(I->Pkg.end() == true)
319 continue;
320
321 pkgDepCache::StateCache &S = Cache[I->Pkg];
322
323 fprintf(F,"%s ",I->Pkg.Name());
324
325 // Current version which we are going to replace
326 pkgCache::VerIterator CurVer = I->Pkg.CurrentVer();
327 if (CurVer.end() == true && (I->Op == Item::Remove || I->Op == Item::Purge))
328 CurVer = FindNowVersion(I->Pkg);
329
330 if (CurVer.end() == true)
331 {
332 if (Version <= 2)
333 fprintf(F, "- ");
334 else
335 fprintf(F, "- - none ");
336 }
337 else
338 {
339 fprintf(F, "%s ", CurVer.VerStr());
340 if (Version >= 3)
341 fprintf(F, "%s %s ", CurVer.Arch(), CurVer.MultiArchType());
342 }
343
344 // Show the compare operator between current and install version
345 if (S.InstallVer != 0)
346 {
347 pkgCache::VerIterator const InstVer = S.InstVerIter(Cache);
348 int Comp = 2;
349 if (CurVer.end() == false)
350 Comp = InstVer.CompareVer(CurVer);
351 if (Comp < 0)
352 fprintf(F,"> ");
353 else if (Comp == 0)
354 fprintf(F,"= ");
355 else if (Comp > 0)
356 fprintf(F,"< ");
357 fprintf(F, "%s ", InstVer.VerStr());
358 if (Version >= 3)
359 fprintf(F, "%s %s ", InstVer.Arch(), InstVer.MultiArchType());
360 }
361 else
362 {
363 if (Version <= 2)
364 fprintf(F, "> - ");
365 else
366 fprintf(F, "> - - none ");
367 }
368
369 // Show the filename/operation
370 if (I->Op == Item::Install)
371 {
372 // No errors here..
373 if (I->File[0] != '/')
374 fprintf(F,"**ERROR**\n");
375 else
376 fprintf(F,"%s\n",I->File.c_str());
377 }
378 else if (I->Op == Item::Configure)
379 fprintf(F,"**CONFIGURE**\n");
380 else if (I->Op == Item::Remove ||
381 I->Op == Item::Purge)
382 fprintf(F,"**REMOVE**\n");
383
384 if (ferror(F) != 0)
385 return false;
386 }
387 return true;
388 }
389 /*}}}*/
390 // DPkgPM::RunScriptsWithPkgs - Run scripts with package names on stdin /*{{{*/
391 // ---------------------------------------------------------------------
392 /* This looks for a list of scripts to run from the configuration file
393 each one is run and is fed on standard input a list of all .deb files
394 that are due to be installed. */
395 bool pkgDPkgPM::RunScriptsWithPkgs(const char *Cnf)
396 {
397 Configuration::Item const *Opts = _config->Tree(Cnf);
398 if (Opts == 0 || Opts->Child == 0)
399 return true;
400 Opts = Opts->Child;
401
402 unsigned int Count = 1;
403 for (; Opts != 0; Opts = Opts->Next, Count++)
404 {
405 if (Opts->Value.empty() == true)
406 continue;
407
408 // Determine the protocol version
409 string OptSec = Opts->Value;
410 string::size_type Pos;
411 if ((Pos = OptSec.find(' ')) == string::npos || Pos == 0)
412 Pos = OptSec.length();
413 OptSec = "DPkg::Tools::Options::" + string(Opts->Value.c_str(),Pos);
414
415 unsigned int Version = _config->FindI(OptSec+"::Version",1);
416 unsigned int InfoFD = _config->FindI(OptSec + "::InfoFD", STDIN_FILENO);
417
418 // Create the pipes
419 std::set<int> KeepFDs;
420 MergeKeepFdsFromConfiguration(KeepFDs);
421 int Pipes[2];
422 if (pipe(Pipes) != 0)
423 return _error->Errno("pipe","Failed to create IPC pipe to subprocess");
424 if (InfoFD != (unsigned)Pipes[0])
425 SetCloseExec(Pipes[0],true);
426 else
427 KeepFDs.insert(Pipes[0]);
428
429
430 SetCloseExec(Pipes[1],true);
431
432 // Purified Fork for running the script
433 pid_t Process = ExecFork(KeepFDs);
434 if (Process == 0)
435 {
436 // Setup the FDs
437 dup2(Pipes[0], InfoFD);
438 SetCloseExec(STDOUT_FILENO,false);
439 SetCloseExec(STDIN_FILENO,false);
440 SetCloseExec(STDERR_FILENO,false);
441
442 string hookfd;
443 strprintf(hookfd, "%d", InfoFD);
444 setenv("APT_HOOK_INFO_FD", hookfd.c_str(), 1);
445
446 dpkgChrootDirectory();
447 const char *Args[4];
448 Args[0] = "/bin/sh";
449 Args[1] = "-c";
450 Args[2] = Opts->Value.c_str();
451 Args[3] = 0;
452 execv(Args[0],(char **)Args);
453 _exit(100);
454 }
455 close(Pipes[0]);
456 FILE *F = fdopen(Pipes[1],"w");
457 if (F == 0)
458 return _error->Errno("fdopen","Faild to open new FD");
459
460 // Feed it the filenames.
461 if (Version <= 1)
462 {
463 for (vector<Item>::iterator I = List.begin(); I != List.end(); ++I)
464 {
465 // Only deal with packages to be installed from .deb
466 if (I->Op != Item::Install)
467 continue;
468
469 // No errors here..
470 if (I->File[0] != '/')
471 continue;
472
473 /* Feed the filename of each package that is pending install
474 into the pipe. */
475 fprintf(F,"%s\n",I->File.c_str());
476 if (ferror(F) != 0)
477 break;
478 }
479 }
480 else
481 SendPkgsInfo(F, Version);
482
483 fclose(F);
484
485 // Clean up the sub process
486 if (ExecWait(Process,Opts->Value.c_str()) == false)
487 return _error->Error("Failure running script %s",Opts->Value.c_str());
488 }
489
490 return true;
491 }
492 /*}}}*/
493 // DPkgPM::DoStdin - Read stdin and pass to slave pty /*{{{*/
494 // ---------------------------------------------------------------------
495 /*
496 */
497 void pkgDPkgPM::DoStdin(int master)
498 {
499 unsigned char input_buf[256] = {0,};
500 ssize_t len = read(0, input_buf, sizeof(input_buf));
501 if (len)
502 FileFd::Write(master, input_buf, len);
503 else
504 d->stdin_is_dev_null = true;
505 }
506 /*}}}*/
507 // DPkgPM::DoTerminalPty - Read the terminal pty and write log /*{{{*/
508 // ---------------------------------------------------------------------
509 /*
510 * read the terminal pty and write log
511 */
512 void pkgDPkgPM::DoTerminalPty(int master)
513 {
514 unsigned char term_buf[1024] = {0,0, };
515
516 ssize_t len=read(master, term_buf, sizeof(term_buf));
517 if(len == -1 && errno == EIO)
518 {
519 // this happens when the child is about to exit, we
520 // give it time to actually exit, otherwise we run
521 // into a race so we sleep for half a second.
522 struct timespec sleepfor = { 0, 500000000 };
523 nanosleep(&sleepfor, NULL);
524 return;
525 }
526 if(len <= 0)
527 return;
528 FileFd::Write(1, term_buf, len);
529 if(d->term_out)
530 fwrite(term_buf, len, sizeof(char), d->term_out);
531 }
532 /*}}}*/
533 // DPkgPM::ProcessDpkgStatusBuf /*{{{*/
534 // ---------------------------------------------------------------------
535 /*
536 */
537 void pkgDPkgPM::ProcessDpkgStatusLine(char *line)
538 {
539 bool const Debug = _config->FindB("Debug::pkgDPkgProgressReporting",false);
540 if (Debug == true)
541 std::clog << "got from dpkg '" << line << "'" << std::endl;
542
543 /* dpkg sends strings like this:
544 'status: <pkg>: <pkg qstate>'
545 'status: <pkg>:<arch>: <pkg qstate>'
546
547 'processing: {install,configure,remove,purge,disappear,trigproc}: pkg'
548 'processing: {install,configure,remove,purge,disappear,trigproc}: trigger'
549 */
550
551 // we need to split on ": " (note the appended space) as the ':' is
552 // part of the pkgname:arch information that dpkg sends
553 //
554 // A dpkg error message may contain additional ":" (like
555 // "failed in buffer_write(fd) (10, ret=-1): backend dpkg-deb ..."
556 // so we need to ensure to not split too much
557 std::vector<std::string> list = StringSplit(line, ": ", 4);
558 if(list.size() < 3)
559 {
560 if (Debug == true)
561 std::clog << "ignoring line: not enough ':'" << std::endl;
562 return;
563 }
564
565 // build the (prefix, pkgname, action) tuple, position of this
566 // is different for "processing" or "status" messages
567 std::string prefix = APT::String::Strip(list[0]);
568 std::string pkgname;
569 std::string action;
570 ostringstream status;
571
572 // "processing" has the form "processing: action: pkg or trigger"
573 // with action = ["install", "configure", "remove", "purge", "disappear",
574 // "trigproc"]
575 if (prefix == "processing")
576 {
577 pkgname = APT::String::Strip(list[2]);
578 action = APT::String::Strip(list[1]);
579 }
580 // "status" has the form: "status: pkg: state"
581 // with state in ["half-installed", "unpacked", "half-configured",
582 // "installed", "config-files", "not-installed"]
583 else if (prefix == "status")
584 {
585 pkgname = APT::String::Strip(list[1]);
586 action = APT::String::Strip(list[2]);
587 } else {
588 if (Debug == true)
589 std::clog << "unknown prefix '" << prefix << "'" << std::endl;
590 return;
591 }
592
593
594 /* handle the special cases first:
595
596 errors look like this:
597 '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
598 and conffile-prompt like this
599 'status: conffile-prompt: conffile : 'current-conffile' 'new-conffile' useredited distedited
600 */
601 if (prefix == "status")
602 {
603 if(action == "error")
604 {
605 d->progress->Error(list[1], PackagesDone, PackagesTotal,
606 list[3]);
607 pkgFailures++;
608 WriteApportReport(list[1].c_str(), list[3].c_str());
609 return;
610 }
611 else if(action == "conffile")
612 {
613 d->progress->ConffilePrompt(list[1], PackagesDone, PackagesTotal,
614 list[3]);
615 return;
616 }
617 }
618
619 // at this point we know that we should have a valid pkgname, so build all
620 // the info from it
621
622 // dpkg does not send always send "pkgname:arch" so we add it here
623 // if needed
624 if (pkgname.find(":") == std::string::npos)
625 {
626 // find the package in the group that is in a touched by dpkg
627 // if there are multiple dpkg will send us a full pkgname:arch
628 pkgCache::GrpIterator Grp = Cache.FindGrp(pkgname);
629 if (Grp.end() == false)
630 {
631 pkgCache::PkgIterator P = Grp.PackageList();
632 for (; P.end() != true; P = Grp.NextPkg(P))
633 {
634 if(Cache[P].Mode != pkgDepCache::ModeKeep)
635 {
636 pkgname = P.FullName();
637 break;
638 }
639 }
640 }
641 }
642
643 const char* const pkg = pkgname.c_str();
644 std::string short_pkgname = StringSplit(pkgname, ":")[0];
645 std::string arch = "";
646 if (pkgname.find(":") != string::npos)
647 arch = StringSplit(pkgname, ":")[1];
648 std::string i18n_pkgname = pkgname;
649 if (arch.size() != 0)
650 strprintf(i18n_pkgname, "%s (%s)", short_pkgname.c_str(), arch.c_str());
651
652 // 'processing' from dpkg looks like
653 // 'processing: action: pkg'
654 if(prefix == "processing")
655 {
656 const std::pair<const char *, const char *> * const iter =
657 std::find_if(PackageProcessingOpsBegin,
658 PackageProcessingOpsEnd,
659 MatchProcessingOp(action.c_str()));
660 if(iter == PackageProcessingOpsEnd)
661 {
662 if (Debug == true)
663 std::clog << "ignoring unknown action: " << action << std::endl;
664 return;
665 }
666 std::string msg;
667 strprintf(msg, _(iter->second), i18n_pkgname.c_str());
668 d->progress->StatusChanged(pkgname, PackagesDone, PackagesTotal, msg);
669
670 // FIXME: this needs a muliarch testcase
671 // FIXME2: is "pkgname" here reliable with dpkg only sending us
672 // short pkgnames?
673 if (action == "disappear")
674 handleDisappearAction(pkgname);
675 return;
676 }
677
678 if (prefix == "status")
679 {
680 vector<struct DpkgState> const &states = PackageOps[pkg];
681 const char *next_action = NULL;
682 if(PackageOpsDone[pkg] < states.size())
683 next_action = states[PackageOpsDone[pkg]].state;
684 // check if the package moved to the next dpkg state
685 if(next_action && (action == next_action))
686 {
687 // only read the translation if there is actually a next
688 // action
689 const char *translation = _(states[PackageOpsDone[pkg]].str);
690 std::string msg;
691
692 // we moved from one dpkg state to a new one, report that
693 PackageOpsDone[pkg]++;
694 PackagesDone++;
695
696 strprintf(msg, translation, i18n_pkgname.c_str());
697 d->progress->StatusChanged(pkgname, PackagesDone, PackagesTotal, msg);
698
699 }
700 if (Debug == true)
701 std::clog << "(parsed from dpkg) pkg: " << short_pkgname
702 << " action: " << action << endl;
703 }
704 }
705 /*}}}*/
706 // DPkgPM::handleDisappearAction /*{{{*/
707 void pkgDPkgPM::handleDisappearAction(string const &pkgname)
708 {
709 pkgCache::PkgIterator Pkg = Cache.FindPkg(pkgname);
710 if (unlikely(Pkg.end() == true))
711 return;
712
713 // record the package name for display and stuff later
714 disappearedPkgs.insert(Pkg.FullName(true));
715
716 // the disappeared package was auto-installed - nothing to do
717 if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
718 return;
719 pkgCache::VerIterator PkgVer = Cache[Pkg].InstVerIter(Cache);
720 if (unlikely(PkgVer.end() == true))
721 return;
722 /* search in the list of dependencies for (Pre)Depends,
723 check if this dependency has a Replaces on our package
724 and if so transfer the manual installed flag to it */
725 for (pkgCache::DepIterator Dep = PkgVer.DependsList(); Dep.end() != true; ++Dep)
726 {
727 if (Dep->Type != pkgCache::Dep::Depends &&
728 Dep->Type != pkgCache::Dep::PreDepends)
729 continue;
730 pkgCache::PkgIterator Tar = Dep.TargetPkg();
731 if (unlikely(Tar.end() == true))
732 continue;
733 // the package is already marked as manual
734 if ((Cache[Tar].Flags & pkgCache::Flag::Auto) != pkgCache::Flag::Auto)
735 continue;
736 pkgCache::VerIterator TarVer = Cache[Tar].InstVerIter(Cache);
737 if (TarVer.end() == true)
738 continue;
739 for (pkgCache::DepIterator Rep = TarVer.DependsList(); Rep.end() != true; ++Rep)
740 {
741 if (Rep->Type != pkgCache::Dep::Replaces)
742 continue;
743 if (Pkg != Rep.TargetPkg())
744 continue;
745 // okay, they are strongly connected - transfer manual-bit
746 if (Debug == true)
747 std::clog << "transfer manual-bit from disappeared »" << pkgname << "« to »" << Tar.FullName() << "«" << std::endl;
748 Cache[Tar].Flags &= ~Flag::Auto;
749 break;
750 }
751 }
752 }
753 /*}}}*/
754 // DPkgPM::DoDpkgStatusFd /*{{{*/
755 // ---------------------------------------------------------------------
756 /*
757 */
758 void pkgDPkgPM::DoDpkgStatusFd(int statusfd)
759 {
760 char *p, *q;
761 int len;
762
763 len=read(statusfd, &d->dpkgbuf[d->dpkgbuf_pos], sizeof(d->dpkgbuf)-d->dpkgbuf_pos);
764 d->dpkgbuf_pos += len;
765 if(len <= 0)
766 return;
767
768 // process line by line if we have a buffer
769 p = q = d->dpkgbuf;
770 while((q=(char*)memchr(p, '\n', d->dpkgbuf+d->dpkgbuf_pos-p)) != NULL)
771 {
772 *q = 0;
773 ProcessDpkgStatusLine(p);
774 p=q+1; // continue with next line
775 }
776
777 // now move the unprocessed bits (after the final \n that is now a 0x0)
778 // to the start and update d->dpkgbuf_pos
779 p = (char*)memrchr(d->dpkgbuf, 0, d->dpkgbuf_pos);
780 if(p == NULL)
781 return;
782
783 // we are interessted in the first char *after* 0x0
784 p++;
785
786 // move the unprocessed tail to the start and update pos
787 memmove(d->dpkgbuf, p, p-d->dpkgbuf);
788 d->dpkgbuf_pos = d->dpkgbuf+d->dpkgbuf_pos-p;
789 }
790 /*}}}*/
791 // DPkgPM::WriteHistoryTag /*{{{*/
792 void pkgDPkgPM::WriteHistoryTag(string const &tag, string value)
793 {
794 size_t const length = value.length();
795 if (length == 0)
796 return;
797 // poor mans rstrip(", ")
798 if (value[length-2] == ',' && value[length-1] == ' ')
799 value.erase(length - 2, 2);
800 fprintf(d->history_out, "%s: %s\n", tag.c_str(), value.c_str());
801 } /*}}}*/
802 // DPkgPM::OpenLog /*{{{*/
803 bool pkgDPkgPM::OpenLog()
804 {
805 string const logdir = _config->FindDir("Dir::Log");
806 if(CreateAPTDirectoryIfNeeded(logdir, logdir) == false)
807 // FIXME: use a better string after freeze
808 return _error->Error(_("Directory '%s' missing"), logdir.c_str());
809
810 // get current time
811 char timestr[200];
812 time_t const t = time(NULL);
813 struct tm const * const tmp = localtime(&t);
814 strftime(timestr, sizeof(timestr), "%F %T", tmp);
815
816 // open terminal log
817 string const logfile_name = flCombine(logdir,
818 _config->Find("Dir::Log::Terminal"));
819 if (!logfile_name.empty())
820 {
821 d->term_out = fopen(logfile_name.c_str(),"a");
822 if (d->term_out == NULL)
823 return _error->WarningE("OpenLog", _("Could not open file '%s'"), logfile_name.c_str());
824 setvbuf(d->term_out, NULL, _IONBF, 0);
825 SetCloseExec(fileno(d->term_out), true);
826 if (getuid() == 0) // if we aren't root, we can't chown a file, so don't try it
827 {
828 struct passwd *pw = getpwnam("root");
829 struct group *gr = getgrnam("adm");
830 if (pw != NULL && gr != NULL && chown(logfile_name.c_str(), pw->pw_uid, gr->gr_gid) != 0)
831 _error->WarningE("OpenLog", "chown to root:adm of file %s failed", logfile_name.c_str());
832 }
833 if (chmod(logfile_name.c_str(), 0640) != 0)
834 _error->WarningE("OpenLog", "chmod 0640 of file %s failed", logfile_name.c_str());
835 fprintf(d->term_out, "\nLog started: %s\n", timestr);
836 }
837
838 // write your history
839 string const history_name = flCombine(logdir,
840 _config->Find("Dir::Log::History"));
841 if (!history_name.empty())
842 {
843 d->history_out = fopen(history_name.c_str(),"a");
844 if (d->history_out == NULL)
845 return _error->WarningE("OpenLog", _("Could not open file '%s'"), history_name.c_str());
846 SetCloseExec(fileno(d->history_out), true);
847 chmod(history_name.c_str(), 0644);
848 fprintf(d->history_out, "\nStart-Date: %s\n", timestr);
849 string remove, purge, install, reinstall, upgrade, downgrade;
850 for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
851 {
852 enum { CANDIDATE, CANDIDATE_AUTO, CURRENT_CANDIDATE, CURRENT } infostring;
853 string *line = NULL;
854 #define HISTORYINFO(X, Y) { line = &X; infostring = Y; }
855 if (Cache[I].NewInstall() == true)
856 HISTORYINFO(install, CANDIDATE_AUTO)
857 else if (Cache[I].ReInstall() == true)
858 HISTORYINFO(reinstall, CANDIDATE)
859 else if (Cache[I].Upgrade() == true)
860 HISTORYINFO(upgrade, CURRENT_CANDIDATE)
861 else if (Cache[I].Downgrade() == true)
862 HISTORYINFO(downgrade, CURRENT_CANDIDATE)
863 else if (Cache[I].Delete() == true)
864 HISTORYINFO((Cache[I].Purge() ? purge : remove), CURRENT)
865 else
866 continue;
867 #undef HISTORYINFO
868 line->append(I.FullName(false)).append(" (");
869 switch (infostring) {
870 case CANDIDATE: line->append(Cache[I].CandVersion); break;
871 case CANDIDATE_AUTO:
872 line->append(Cache[I].CandVersion);
873 if ((Cache[I].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
874 line->append(", automatic");
875 break;
876 case CURRENT_CANDIDATE: line->append(Cache[I].CurVersion).append(", ").append(Cache[I].CandVersion); break;
877 case CURRENT: line->append(Cache[I].CurVersion); break;
878 }
879 line->append("), ");
880 }
881 if (_config->Exists("Commandline::AsString") == true)
882 WriteHistoryTag("Commandline", _config->Find("Commandline::AsString"));
883 WriteHistoryTag("Install", install);
884 WriteHistoryTag("Reinstall", reinstall);
885 WriteHistoryTag("Upgrade", upgrade);
886 WriteHistoryTag("Downgrade",downgrade);
887 WriteHistoryTag("Remove",remove);
888 WriteHistoryTag("Purge",purge);
889 fflush(d->history_out);
890 }
891
892 return true;
893 }
894 /*}}}*/
895 // DPkg::CloseLog /*{{{*/
896 bool pkgDPkgPM::CloseLog()
897 {
898 char timestr[200];
899 time_t t = time(NULL);
900 struct tm *tmp = localtime(&t);
901 strftime(timestr, sizeof(timestr), "%F %T", tmp);
902
903 if(d->term_out)
904 {
905 fprintf(d->term_out, "Log ended: ");
906 fprintf(d->term_out, "%s", timestr);
907 fprintf(d->term_out, "\n");
908 fclose(d->term_out);
909 }
910 d->term_out = NULL;
911
912 if(d->history_out)
913 {
914 if (disappearedPkgs.empty() == false)
915 {
916 string disappear;
917 for (std::set<std::string>::const_iterator d = disappearedPkgs.begin();
918 d != disappearedPkgs.end(); ++d)
919 {
920 pkgCache::PkgIterator P = Cache.FindPkg(*d);
921 disappear.append(*d);
922 if (P.end() == true)
923 disappear.append(", ");
924 else
925 disappear.append(" (").append(Cache[P].CurVersion).append("), ");
926 }
927 WriteHistoryTag("Disappeared", disappear);
928 }
929 if (d->dpkg_error.empty() == false)
930 fprintf(d->history_out, "Error: %s\n", d->dpkg_error.c_str());
931 fprintf(d->history_out, "End-Date: %s\n", timestr);
932 fclose(d->history_out);
933 }
934 d->history_out = NULL;
935
936 return true;
937 }
938 /*}}}*/
939 /*}}}*/
940 /*{{{*/
941 // This implements a racy version of pselect for those architectures
942 // that don't have a working implementation.
943 // FIXME: Probably can be removed on Lenny+1
944 static int racy_pselect(int nfds, fd_set *readfds, fd_set *writefds,
945 fd_set *exceptfds, const struct timespec *timeout,
946 const sigset_t *sigmask)
947 {
948 sigset_t origmask;
949 struct timeval tv;
950 int retval;
951
952 tv.tv_sec = timeout->tv_sec;
953 tv.tv_usec = timeout->tv_nsec/1000;
954
955 sigprocmask(SIG_SETMASK, sigmask, &origmask);
956 retval = select(nfds, readfds, writefds, exceptfds, &tv);
957 sigprocmask(SIG_SETMASK, &origmask, 0);
958 return retval;
959 }
960 /*}}}*/
961
962 // DPkgPM::BuildPackagesProgressMap /*{{{*/
963 void pkgDPkgPM::BuildPackagesProgressMap()
964 {
965 // map the dpkg states to the operations that are performed
966 // (this is sorted in the same way as Item::Ops)
967 static const struct DpkgState DpkgStatesOpMap[][7] = {
968 // Install operation
969 {
970 {"half-installed", N_("Preparing %s")},
971 {"unpacked", N_("Unpacking %s") },
972 {NULL, NULL}
973 },
974 // Configure operation
975 {
976 {"unpacked",N_("Preparing to configure %s") },
977 {"half-configured", N_("Configuring %s") },
978 { "installed", N_("Installed %s")},
979 {NULL, NULL}
980 },
981 // Remove operation
982 {
983 {"half-configured", N_("Preparing for removal of %s")},
984 {"half-installed", N_("Removing %s")},
985 {"config-files", N_("Removed %s")},
986 {NULL, NULL}
987 },
988 // Purge operation
989 {
990 {"config-files", N_("Preparing to completely remove %s")},
991 {"not-installed", N_("Completely removed %s")},
992 {NULL, NULL}
993 },
994 };
995
996 // init the PackageOps map, go over the list of packages that
997 // that will be [installed|configured|removed|purged] and add
998 // them to the PackageOps map (the dpkg states it goes through)
999 // and the PackageOpsTranslations (human readable strings)
1000 for (vector<Item>::const_iterator I = List.begin(); I != List.end(); ++I)
1001 {
1002 if((*I).Pkg.end() == true)
1003 continue;
1004
1005 string const name = (*I).Pkg.FullName();
1006 PackageOpsDone[name] = 0;
1007 for(int i=0; (DpkgStatesOpMap[(*I).Op][i]).state != NULL; ++i)
1008 {
1009 PackageOps[name].push_back(DpkgStatesOpMap[(*I).Op][i]);
1010 PackagesTotal++;
1011 }
1012 }
1013 }
1014 /*}}}*/
1015 #if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR < 13)
1016 bool pkgDPkgPM::Go(int StatusFd)
1017 {
1018 APT::Progress::PackageManager *progress = NULL;
1019 if (StatusFd == -1)
1020 progress = APT::Progress::PackageManagerProgressFactory();
1021 else
1022 progress = new APT::Progress::PackageManagerProgressFd(StatusFd);
1023
1024 return GoNoABIBreak(progress);
1025 }
1026 #endif
1027
1028 void pkgDPkgPM::StartPtyMagic()
1029 {
1030 // setup the pty and stuff
1031 struct winsize win;
1032
1033 // if tcgetattr does not return zero there was a error
1034 // and we do not do any pty magic
1035 _error->PushToStack();
1036 if (tcgetattr(STDOUT_FILENO, &d->tt) == 0)
1037 {
1038 ioctl(1, TIOCGWINSZ, (char *)&win);
1039 if (openpty(&d->master, &d->slave, NULL, &d->tt, &win) < 0)
1040 {
1041 _error->Errno("openpty", _("Can not write log (%s)"), _("Is /dev/pts mounted?"));
1042 d->master = d->slave = -1;
1043 } else {
1044 struct termios rtt;
1045 rtt = d->tt;
1046 cfmakeraw(&rtt);
1047 rtt.c_lflag &= ~ECHO;
1048 rtt.c_lflag |= ISIG;
1049 // block SIGTTOU during tcsetattr to prevent a hang if
1050 // the process is a member of the background process group
1051 // http://www.opengroup.org/onlinepubs/000095399/functions/tcsetattr.html
1052 sigemptyset(&d->sigmask);
1053 sigaddset(&d->sigmask, SIGTTOU);
1054 sigprocmask(SIG_BLOCK,&d->sigmask, &d->original_sigmask);
1055 tcsetattr(0, TCSAFLUSH, &rtt);
1056 sigprocmask(SIG_SETMASK, &d->original_sigmask, 0);
1057 }
1058 }
1059 // complain only if stdout is either a terminal (but still failed) or is an invalid
1060 // descriptor otherwise we would complain about redirection to e.g. /dev/null as well.
1061 else if (isatty(STDOUT_FILENO) == 1 || errno == EBADF)
1062 _error->Errno("tcgetattr", _("Can not write log (%s)"), _("Is stdout a terminal?"));
1063
1064 if (_error->PendingError() == true)
1065 _error->DumpErrors(std::cerr);
1066 _error->RevertToStack();
1067 }
1068
1069 void pkgDPkgPM::StopPtyMagic()
1070 {
1071 if(d->slave > 0)
1072 close(d->slave);
1073 if(d->master >= 0)
1074 {
1075 tcsetattr(0, TCSAFLUSH, &d->tt);
1076 close(d->master);
1077 }
1078 }
1079
1080 // DPkgPM::Go - Run the sequence /*{{{*/
1081 // ---------------------------------------------------------------------
1082 /* This globs the operations and calls dpkg
1083 *
1084 * If it is called with a progress object apt will report the install
1085 * progress to this object. It maps the dpkg states a package goes
1086 * through to human readable (and i10n-able)
1087 * names and calculates a percentage for each step.
1088 */
1089 #if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR >= 13)
1090 bool pkgDPkgPM::Go(APT::Progress::PackageManager *progress)
1091 #else
1092 bool pkgDPkgPM::GoNoABIBreak(APT::Progress::PackageManager *progress)
1093 #endif
1094 {
1095 pkgPackageManager::SigINTStop = false;
1096 d->progress = progress;
1097
1098 // Generate the base argument list for dpkg
1099 unsigned long StartSize = 0;
1100 std::vector<const char *> Args;
1101 std::string DpkgExecutable = getDpkgExecutable();
1102 Args.push_back(DpkgExecutable.c_str());
1103 StartSize += DpkgExecutable.length();
1104
1105 // Stick in any custom dpkg options
1106 Configuration::Item const *Opts = _config->Tree("DPkg::Options");
1107 if (Opts != 0)
1108 {
1109 Opts = Opts->Child;
1110 for (; Opts != 0; Opts = Opts->Next)
1111 {
1112 if (Opts->Value.empty() == true)
1113 continue;
1114 Args.push_back(Opts->Value.c_str());
1115 StartSize += Opts->Value.length();
1116 }
1117 }
1118
1119 size_t const BaseArgs = Args.size();
1120 // we need to detect if we can qualify packages with the architecture or not
1121 Args.push_back("--assert-multi-arch");
1122 Args.push_back(NULL);
1123
1124 pid_t dpkgAssertMultiArch = ExecFork();
1125 if (dpkgAssertMultiArch == 0)
1126 {
1127 dpkgChrootDirectory();
1128 // redirect everything to the ultimate sink as we only need the exit-status
1129 int const nullfd = open("/dev/null", O_RDONLY);
1130 dup2(nullfd, STDIN_FILENO);
1131 dup2(nullfd, STDOUT_FILENO);
1132 dup2(nullfd, STDERR_FILENO);
1133 execvp(Args[0], (char**) &Args[0]);
1134 _error->WarningE("dpkgGo", "Can't detect if dpkg supports multi-arch!");
1135 _exit(2);
1136 }
1137
1138 fd_set rfds;
1139 struct timespec tv;
1140
1141 unsigned int const MaxArgs = _config->FindI("Dpkg::MaxArgs",8*1024);
1142 unsigned int const MaxArgBytes = _config->FindI("Dpkg::MaxArgBytes",32*1024);
1143 bool const NoTriggers = _config->FindB("DPkg::NoTriggers", false);
1144
1145 if (RunScripts("DPkg::Pre-Invoke") == false)
1146 return false;
1147
1148 if (RunScriptsWithPkgs("DPkg::Pre-Install-Pkgs") == false)
1149 return false;
1150
1151 // support subpressing of triggers processing for special
1152 // cases like d-i that runs the triggers handling manually
1153 bool const SmartConf = (_config->Find("PackageManager::Configure", "all") != "all");
1154 bool const TriggersPending = _config->FindB("DPkg::TriggersPending", false);
1155 if (_config->FindB("DPkg::ConfigurePending", SmartConf) == true)
1156 List.push_back(Item(Item::ConfigurePending, PkgIterator()));
1157
1158 // for the progress
1159 BuildPackagesProgressMap();
1160
1161 d->stdin_is_dev_null = false;
1162
1163 // create log
1164 OpenLog();
1165
1166 bool dpkgMultiArch = false;
1167 if (dpkgAssertMultiArch > 0)
1168 {
1169 int Status = 0;
1170 while (waitpid(dpkgAssertMultiArch, &Status, 0) != dpkgAssertMultiArch)
1171 {
1172 if (errno == EINTR)
1173 continue;
1174 _error->WarningE("dpkgGo", _("Waited for %s but it wasn't there"), "dpkg --assert-multi-arch");
1175 break;
1176 }
1177 if (WIFEXITED(Status) == true && WEXITSTATUS(Status) == 0)
1178 dpkgMultiArch = true;
1179 }
1180
1181 // start pty magic before the loop
1182 StartPtyMagic();
1183
1184 // Tell the progress that its starting and fork dpkg
1185 d->progress->Start();
1186
1187 // this loop is runs once per dpkg operation
1188 vector<Item>::const_iterator I = List.begin();
1189 while (I != List.end())
1190 {
1191 // Do all actions with the same Op in one run
1192 vector<Item>::const_iterator J = I;
1193 if (TriggersPending == true)
1194 for (; J != List.end(); ++J)
1195 {
1196 if (J->Op == I->Op)
1197 continue;
1198 if (J->Op != Item::TriggersPending)
1199 break;
1200 vector<Item>::const_iterator T = J + 1;
1201 if (T != List.end() && T->Op == I->Op)
1202 continue;
1203 break;
1204 }
1205 else
1206 for (; J != List.end() && J->Op == I->Op; ++J)
1207 /* nothing */;
1208
1209 // keep track of allocated strings for multiarch package names
1210 std::vector<char *> Packages;
1211
1212 // start with the baseset of arguments
1213 unsigned long Size = StartSize;
1214 Args.erase(Args.begin() + BaseArgs, Args.end());
1215
1216 // Now check if we are within the MaxArgs limit
1217 //
1218 // this code below is problematic, because it may happen that
1219 // the argument list is split in a way that A depends on B
1220 // and they are in the same "--configure A B" run
1221 // - with the split they may now be configured in different
1222 // runs, using Immediate-Configure-All can help prevent this.
1223 if (J - I > (signed)MaxArgs)
1224 {
1225 J = I + MaxArgs;
1226 unsigned long const size = MaxArgs + 10;
1227 Args.reserve(size);
1228 Packages.reserve(size);
1229 }
1230 else
1231 {
1232 unsigned long const size = (J - I) + 10;
1233 Args.reserve(size);
1234 Packages.reserve(size);
1235 }
1236
1237 int fd[2];
1238 if (pipe(fd) != 0)
1239 return _error->Errno("pipe","Failed to create IPC pipe to dpkg");
1240
1241 #define ADDARG(X) Args.push_back(X); Size += strlen(X)
1242 #define ADDARGC(X) Args.push_back(X); Size += sizeof(X) - 1
1243
1244 ADDARGC("--status-fd");
1245 char status_fd_buf[20];
1246 snprintf(status_fd_buf,sizeof(status_fd_buf),"%i", fd[1]);
1247 ADDARG(status_fd_buf);
1248 unsigned long const Op = I->Op;
1249
1250 switch (I->Op)
1251 {
1252 case Item::Remove:
1253 ADDARGC("--force-depends");
1254 ADDARGC("--force-remove-essential");
1255 ADDARGC("--remove");
1256 break;
1257
1258 case Item::Purge:
1259 ADDARGC("--force-depends");
1260 ADDARGC("--force-remove-essential");
1261 ADDARGC("--purge");
1262 break;
1263
1264 case Item::Configure:
1265 ADDARGC("--configure");
1266 break;
1267
1268 case Item::ConfigurePending:
1269 ADDARGC("--configure");
1270 ADDARGC("--pending");
1271 break;
1272
1273 case Item::TriggersPending:
1274 ADDARGC("--triggers-only");
1275 ADDARGC("--pending");
1276 break;
1277
1278 case Item::Install:
1279 ADDARGC("--unpack");
1280 ADDARGC("--auto-deconfigure");
1281 break;
1282 }
1283
1284 if (NoTriggers == true && I->Op != Item::TriggersPending &&
1285 I->Op != Item::ConfigurePending)
1286 {
1287 ADDARGC("--no-triggers");
1288 }
1289 #undef ADDARGC
1290
1291 // Write in the file or package names
1292 if (I->Op == Item::Install)
1293 {
1294 for (;I != J && Size < MaxArgBytes; ++I)
1295 {
1296 if (I->File[0] != '/')
1297 return _error->Error("Internal Error, Pathname to install is not absolute '%s'",I->File.c_str());
1298 Args.push_back(I->File.c_str());
1299 Size += I->File.length();
1300 }
1301 }
1302 else
1303 {
1304 string const nativeArch = _config->Find("APT::Architecture");
1305 unsigned long const oldSize = I->Op == Item::Configure ? Size : 0;
1306 for (;I != J && Size < MaxArgBytes; ++I)
1307 {
1308 if((*I).Pkg.end() == true)
1309 continue;
1310 if (I->Op == Item::Configure && disappearedPkgs.find(I->Pkg.FullName(true)) != disappearedPkgs.end())
1311 continue;
1312 // We keep this here to allow "smooth" transitions from e.g. multiarch dpkg/ubuntu to dpkg/debian
1313 if (dpkgMultiArch == false && (I->Pkg.Arch() == nativeArch ||
1314 strcmp(I->Pkg.Arch(), "all") == 0 ||
1315 strcmp(I->Pkg.Arch(), "none") == 0))
1316 {
1317 char const * const name = I->Pkg.Name();
1318 ADDARG(name);
1319 }
1320 else
1321 {
1322 pkgCache::VerIterator PkgVer;
1323 std::string name = I->Pkg.Name();
1324 if (Op == Item::Remove || Op == Item::Purge)
1325 {
1326 PkgVer = I->Pkg.CurrentVer();
1327 if(PkgVer.end() == true)
1328 PkgVer = FindNowVersion(I->Pkg);
1329 }
1330 else
1331 PkgVer = Cache[I->Pkg].InstVerIter(Cache);
1332 if (strcmp(I->Pkg.Arch(), "none") == 0)
1333 ; // never arch-qualify a package without an arch
1334 else if (PkgVer.end() == false)
1335 name.append(":").append(PkgVer.Arch());
1336 else
1337 _error->Warning("Can not find PkgVer for '%s'", name.c_str());
1338 char * const fullname = strdup(name.c_str());
1339 Packages.push_back(fullname);
1340 ADDARG(fullname);
1341 }
1342 }
1343 // skip configure action if all sheduled packages disappeared
1344 if (oldSize == Size)
1345 continue;
1346 }
1347 #undef ADDARG
1348
1349 J = I;
1350
1351 if (_config->FindB("Debug::pkgDPkgPM",false) == true)
1352 {
1353 for (std::vector<const char *>::const_iterator a = Args.begin();
1354 a != Args.end(); ++a)
1355 clog << *a << ' ';
1356 clog << endl;
1357 continue;
1358 }
1359 Args.push_back(NULL);
1360
1361 cout << flush;
1362 clog << flush;
1363 cerr << flush;
1364
1365 /* Mask off sig int/quit. We do this because dpkg also does when
1366 it forks scripts. What happens is that when you hit ctrl-c it sends
1367 it to all processes in the group. Since dpkg ignores the signal
1368 it doesn't die but we do! So we must also ignore it */
1369 sighandler_t old_SIGQUIT = signal(SIGQUIT,SIG_IGN);
1370 sighandler_t old_SIGINT = signal(SIGINT,SigINT);
1371
1372 // Check here for any SIGINT
1373 if (pkgPackageManager::SigINTStop && (Op == Item::Remove || Op == Item::Purge || Op == Item::Install))
1374 break;
1375
1376
1377 // ignore SIGHUP as well (debian #463030)
1378 sighandler_t old_SIGHUP = signal(SIGHUP,SIG_IGN);
1379
1380 // now run dpkg
1381 d->progress->StartDpkg();
1382 std::set<int> KeepFDs;
1383 KeepFDs.insert(fd[1]);
1384 MergeKeepFdsFromConfiguration(KeepFDs);
1385 pid_t Child = ExecFork(KeepFDs);
1386 if (Child == 0)
1387 {
1388 // This is the child
1389 if(d->slave >= 0 && d->master >= 0)
1390 {
1391 setsid();
1392 ioctl(d->slave, TIOCSCTTY, 0);
1393 close(d->master);
1394 dup2(d->slave, 0);
1395 dup2(d->slave, 1);
1396 dup2(d->slave, 2);
1397 close(d->slave);
1398 }
1399 close(fd[0]); // close the read end of the pipe
1400
1401 dpkgChrootDirectory();
1402
1403 if (chdir(_config->FindDir("DPkg::Run-Directory","/").c_str()) != 0)
1404 _exit(100);
1405
1406 if (_config->FindB("DPkg::FlushSTDIN",true) == true && isatty(STDIN_FILENO))
1407 {
1408 int Flags,dummy;
1409 if ((Flags = fcntl(STDIN_FILENO,F_GETFL,dummy)) < 0)
1410 _exit(100);
1411
1412 // Discard everything in stdin before forking dpkg
1413 if (fcntl(STDIN_FILENO,F_SETFL,Flags | O_NONBLOCK) < 0)
1414 _exit(100);
1415
1416 while (read(STDIN_FILENO,&dummy,1) == 1);
1417
1418 if (fcntl(STDIN_FILENO,F_SETFL,Flags & (~(long)O_NONBLOCK)) < 0)
1419 _exit(100);
1420 }
1421
1422 /* No Job Control Stop Env is a magic dpkg var that prevents it
1423 from using sigstop */
1424 putenv((char *)"DPKG_NO_TSTP=yes");
1425 execvp(Args[0], (char**) &Args[0]);
1426 cerr << "Could not exec dpkg!" << endl;
1427 _exit(100);
1428 }
1429
1430 // apply ionice
1431 if (_config->FindB("DPkg::UseIoNice", false) == true)
1432 ionice(Child);
1433
1434 // Wait for dpkg
1435 int Status = 0;
1436
1437 // we read from dpkg here
1438 int const _dpkgin = fd[0];
1439 close(fd[1]); // close the write end of the pipe
1440
1441 // setups fds
1442 sigemptyset(&d->sigmask);
1443 sigprocmask(SIG_BLOCK,&d->sigmask,&d->original_sigmask);
1444
1445 /* free vectors (and therefore memory) as we don't need the included data anymore */
1446 for (std::vector<char *>::const_iterator p = Packages.begin();
1447 p != Packages.end(); ++p)
1448 free(*p);
1449 Packages.clear();
1450
1451 // the result of the waitpid call
1452 int res;
1453 int select_ret;
1454 while ((res=waitpid(Child,&Status, WNOHANG)) != Child) {
1455 if(res < 0) {
1456 // FIXME: move this to a function or something, looks ugly here
1457 // error handling, waitpid returned -1
1458 if (errno == EINTR)
1459 continue;
1460 RunScripts("DPkg::Post-Invoke");
1461
1462 // Restore sig int/quit
1463 signal(SIGQUIT,old_SIGQUIT);
1464 signal(SIGINT,old_SIGINT);
1465
1466 signal(SIGHUP,old_SIGHUP);
1467 return _error->Errno("waitpid","Couldn't wait for subprocess");
1468 }
1469
1470 // wait for input or output here
1471 FD_ZERO(&rfds);
1472 if (d->master >= 0 && !d->stdin_is_dev_null)
1473 FD_SET(0, &rfds);
1474 FD_SET(_dpkgin, &rfds);
1475 if(d->master >= 0)
1476 FD_SET(d->master, &rfds);
1477 tv.tv_sec = 0;
1478 tv.tv_nsec = d->progress->GetPulseInterval();
1479 select_ret = pselect(max(d->master, _dpkgin)+1, &rfds, NULL, NULL,
1480 &tv, &d->original_sigmask);
1481 if (select_ret < 0 && (errno == EINVAL || errno == ENOSYS))
1482 select_ret = racy_pselect(max(d->master, _dpkgin)+1, &rfds, NULL,
1483 NULL, &tv, &d->original_sigmask);
1484 d->progress->Pulse();
1485 if (select_ret == 0)
1486 continue;
1487 else if (select_ret < 0 && errno == EINTR)
1488 continue;
1489 else if (select_ret < 0)
1490 {
1491 perror("select() returned error");
1492 continue;
1493 }
1494
1495 if(d->master >= 0 && FD_ISSET(d->master, &rfds))
1496 DoTerminalPty(d->master);
1497 if(d->master >= 0 && FD_ISSET(0, &rfds))
1498 DoStdin(d->master);
1499 if(FD_ISSET(_dpkgin, &rfds))
1500 DoDpkgStatusFd(_dpkgin);
1501 }
1502 close(_dpkgin);
1503
1504 // Restore sig int/quit
1505 signal(SIGQUIT,old_SIGQUIT);
1506 signal(SIGINT,old_SIGINT);
1507
1508 signal(SIGHUP,old_SIGHUP);
1509 // Check for an error code.
1510 if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
1511 {
1512 // if it was set to "keep-dpkg-runing" then we won't return
1513 // here but keep the loop going and just report it as a error
1514 // for later
1515 bool const stopOnError = _config->FindB("Dpkg::StopOnError",true);
1516
1517 if(stopOnError)
1518 RunScripts("DPkg::Post-Invoke");
1519
1520 if (WIFSIGNALED(Status) != 0 && WTERMSIG(Status) == SIGSEGV)
1521 strprintf(d->dpkg_error, "Sub-process %s received a segmentation fault.",Args[0]);
1522 else if (WIFEXITED(Status) != 0)
1523 strprintf(d->dpkg_error, "Sub-process %s returned an error code (%u)",Args[0],WEXITSTATUS(Status));
1524 else
1525 strprintf(d->dpkg_error, "Sub-process %s exited unexpectedly",Args[0]);
1526
1527 if(d->dpkg_error.size() > 0)
1528 _error->Error("%s", d->dpkg_error.c_str());
1529
1530 if(stopOnError)
1531 {
1532 CloseLog();
1533 StopPtyMagic();
1534 d->progress->Stop();
1535 return false;
1536 }
1537 }
1538 }
1539 // dpkg is done at this point
1540 d->progress->Stop();
1541 StopPtyMagic();
1542 CloseLog();
1543
1544 if (pkgPackageManager::SigINTStop)
1545 _error->Warning(_("Operation was interrupted before it could finish"));
1546
1547 if (RunScripts("DPkg::Post-Invoke") == false)
1548 return false;
1549
1550 if (_config->FindB("Debug::pkgDPkgPM",false) == false)
1551 {
1552 std::string const oldpkgcache = _config->FindFile("Dir::cache::pkgcache");
1553 if (oldpkgcache.empty() == false && RealFileExists(oldpkgcache) == true &&
1554 unlink(oldpkgcache.c_str()) == 0)
1555 {
1556 std::string const srcpkgcache = _config->FindFile("Dir::cache::srcpkgcache");
1557 if (srcpkgcache.empty() == false && RealFileExists(srcpkgcache) == true)
1558 {
1559 _error->PushToStack();
1560 pkgCacheFile CacheFile;
1561 CacheFile.BuildCaches(NULL, true);
1562 _error->RevertToStack();
1563 }
1564 }
1565 }
1566
1567 Cache.writeStateFile(NULL);
1568 return true;
1569 }
1570
1571 void SigINT(int sig) {
1572 pkgPackageManager::SigINTStop = true;
1573 }
1574 /*}}}*/
1575 // pkgDpkgPM::Reset - Dump the contents of the command list /*{{{*/
1576 // ---------------------------------------------------------------------
1577 /* */
1578 void pkgDPkgPM::Reset()
1579 {
1580 List.erase(List.begin(),List.end());
1581 }
1582 /*}}}*/
1583 // pkgDpkgPM::WriteApportReport - write out error report pkg failure /*{{{*/
1584 // ---------------------------------------------------------------------
1585 /* */
1586 void pkgDPkgPM::WriteApportReport(const char *pkgpath, const char *errormsg)
1587 {
1588 // If apport doesn't exist or isn't installed do nothing
1589 // This e.g. prevents messages in 'universes' without apport
1590 pkgCache::PkgIterator apportPkg = Cache.FindPkg("apport");
1591 if (apportPkg.end() == true || apportPkg->CurrentVer == 0)
1592 return;
1593
1594 string pkgname, reportfile, srcpkgname, pkgver, arch;
1595 string::size_type pos;
1596 FILE *report;
1597
1598 if (_config->FindB("Dpkg::ApportFailureReport", false) == false)
1599 {
1600 std::clog << "configured to not write apport reports" << std::endl;
1601 return;
1602 }
1603
1604 // only report the first errors
1605 if(pkgFailures > _config->FindI("APT::Apport::MaxReports", 3))
1606 {
1607 std::clog << _("No apport report written because MaxReports is reached already") << std::endl;
1608 return;
1609 }
1610
1611 // check if its not a follow up error
1612 const char *needle = dgettext("dpkg", "dependency problems - leaving unconfigured");
1613 if(strstr(errormsg, needle) != NULL) {
1614 std::clog << _("No apport report written because the error message indicates its a followup error from a previous failure.") << std::endl;
1615 return;
1616 }
1617
1618 // do not report disk-full failures
1619 if(strstr(errormsg, strerror(ENOSPC)) != NULL) {
1620 std::clog << _("No apport report written because the error message indicates a disk full error") << std::endl;
1621 return;
1622 }
1623
1624 // do not report out-of-memory failures
1625 if(strstr(errormsg, strerror(ENOMEM)) != NULL) {
1626 std::clog << _("No apport report written because the error message indicates a out of memory error") << std::endl;
1627 return;
1628 }
1629
1630 // do not report dpkg I/O errors
1631 // XXX - this message is localized, but this only matches the English version. This is better than nothing.
1632 if(strstr(errormsg, "short read in buffer_copy (")) {
1633 std::clog << _("No apport report written because the error message indicates a dpkg I/O error") << std::endl;
1634 return;
1635 }
1636
1637 // get the pkgname and reportfile
1638 pkgname = flNotDir(pkgpath);
1639 pos = pkgname.find('_');
1640 if(pos != string::npos)
1641 pkgname = pkgname.substr(0, pos);
1642
1643 // find the package versin and source package name
1644 pkgCache::PkgIterator Pkg = Cache.FindPkg(pkgname);
1645 if (Pkg.end() == true)
1646 return;
1647 pkgCache::VerIterator Ver = Cache.GetCandidateVer(Pkg);
1648 if (Ver.end() == true)
1649 return;
1650 pkgver = Ver.VerStr() == NULL ? "unknown" : Ver.VerStr();
1651 pkgRecords Recs(Cache);
1652 pkgRecords::Parser &Parse = Recs.Lookup(Ver.FileList());
1653 srcpkgname = Parse.SourcePkg();
1654 if(srcpkgname.empty())
1655 srcpkgname = pkgname;
1656
1657 // if the file exists already, we check:
1658 // - if it was reported already (touched by apport).
1659 // If not, we do nothing, otherwise
1660 // we overwrite it. This is the same behaviour as apport
1661 // - if we have a report with the same pkgversion already
1662 // then we skip it
1663 reportfile = flCombine("/var/crash",pkgname+".0.crash");
1664 if(FileExists(reportfile))
1665 {
1666 struct stat buf;
1667 char strbuf[255];
1668
1669 // check atime/mtime
1670 stat(reportfile.c_str(), &buf);
1671 if(buf.st_mtime > buf.st_atime)
1672 return;
1673
1674 // check if the existing report is the same version
1675 report = fopen(reportfile.c_str(),"r");
1676 while(fgets(strbuf, sizeof(strbuf), report) != NULL)
1677 {
1678 if(strstr(strbuf,"Package:") == strbuf)
1679 {
1680 char pkgname[255], version[255];
1681 if(sscanf(strbuf, "Package: %254s %254s", pkgname, version) == 2)
1682 if(strcmp(pkgver.c_str(), version) == 0)
1683 {
1684 fclose(report);
1685 return;
1686 }
1687 }
1688 }
1689 fclose(report);
1690 }
1691
1692 // now write the report
1693 arch = _config->Find("APT::Architecture");
1694 report = fopen(reportfile.c_str(),"w");
1695 if(report == NULL)
1696 return;
1697 if(_config->FindB("DPkgPM::InitialReportOnly",false) == true)
1698 chmod(reportfile.c_str(), 0);
1699 else
1700 chmod(reportfile.c_str(), 0600);
1701 fprintf(report, "ProblemType: Package\n");
1702 fprintf(report, "Architecture: %s\n", arch.c_str());
1703 time_t now = time(NULL);
1704 fprintf(report, "Date: %s" , ctime(&now));
1705 fprintf(report, "Package: %s %s\n", pkgname.c_str(), pkgver.c_str());
1706 fprintf(report, "SourcePackage: %s\n", srcpkgname.c_str());
1707 fprintf(report, "ErrorMessage:\n %s\n", errormsg);
1708
1709 // ensure that the log is flushed
1710 if(d->term_out)
1711 fflush(d->term_out);
1712
1713 // attach terminal log it if we have it
1714 string logfile_name = _config->FindFile("Dir::Log::Terminal");
1715 if (!logfile_name.empty())
1716 {
1717 FILE *log = NULL;
1718
1719 fprintf(report, "DpkgTerminalLog:\n");
1720 log = fopen(logfile_name.c_str(),"r");
1721 if(log != NULL)
1722 {
1723 char buf[1024];
1724 while( fgets(buf, sizeof(buf), log) != NULL)
1725 fprintf(report, " %s", buf);
1726 fclose(log);
1727 }
1728 }
1729
1730 // log the ordering
1731 const char *ops_str[] = {"Install", "Configure","Remove","Purge"};
1732 fprintf(report, "AptOrdering:\n");
1733 for (vector<Item>::iterator I = List.begin(); I != List.end(); ++I)
1734 if ((*I).Pkg != NULL)
1735 fprintf(report, " %s: %s\n", (*I).Pkg.Name(), ops_str[(*I).Op]);
1736 else
1737 fprintf(report, " %s: %s\n", "NULL", ops_str[(*I).Op]);
1738
1739 // attach dmesg log (to learn about segfaults)
1740 if (FileExists("/bin/dmesg"))
1741 {
1742 fprintf(report, "Dmesg:\n");
1743 FILE *log = popen("/bin/dmesg","r");
1744 if(log != NULL)
1745 {
1746 char buf[1024];
1747 while( fgets(buf, sizeof(buf), log) != NULL)
1748 fprintf(report, " %s", buf);
1749 pclose(log);
1750 }
1751 }
1752
1753 // attach df -l log (to learn about filesystem status)
1754 if (FileExists("/bin/df"))
1755 {
1756
1757 fprintf(report, "Df:\n");
1758 FILE *log = popen("/bin/df -l","r");
1759 if(log != NULL)
1760 {
1761 char buf[1024];
1762 while( fgets(buf, sizeof(buf), log) != NULL)
1763 fprintf(report, " %s", buf);
1764 pclose(log);
1765 }
1766 }
1767
1768 fclose(report);
1769
1770 }
1771 /*}}}*/
APT (for Cydia)