]> git.saurik.com Git - apt.git/blame - apt-pkg/deb/dpkgpm.cc
test/test-indexes.sh: Stop hardcoding archive gpg key ID, get it from first failed...
[apt.git] / apt-pkg / deb / dpkgpm.cc
CommitLineData
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
42using namespace std;
03e39e59 43
f7dec19f
DB
44namespace
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*/
83static bool
84ionice(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 106pkgDPkgPM::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/* */
115pkgDPkgPM::~pkgDPkgPM()
116{
117}
118 /*}}}*/
119// DPkgPM::Install - Install a package /*{{{*/
120// ---------------------------------------------------------------------
121/* Add an install operation to the sequence list */
122bool 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 */
134bool 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 152bool 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.*/
168bool 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. */
256bool 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*/
350void 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 365void 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 389void 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 520void 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 /*{{{*/
554void 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
565bool 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
627bool 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
658static 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*/
684bool 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/* */
1149void pkgDPkgPM::Reset()
1150{
1151 List.erase(List.begin(),List.end());
1152}
1153 /*}}}*/