Commit | Line | Data |
---|---|---|
c0c0b100 | 1 | // -*- mode: cpp; mode: fold -*- |
03e39e59 | 2 | // Description /*{{{*/ |
7f9a6360 | 3 | // $Id: dpkgpm.cc,v 1.28 2004/01/27 02:25:01 mdz Exp $ |
03e39e59 AL |
4 | /* ###################################################################### |
5 | ||
6 | DPKG Package Manager - Provide an interface to dpkg | |
7 | ||
8 | ##################################################################### */ | |
9 | /*}}}*/ | |
10 | // Includes /*{{{*/ | |
03e39e59 AL |
11 | #include <apt-pkg/dpkgpm.h> |
12 | #include <apt-pkg/error.h> | |
13 | #include <apt-pkg/configuration.h> | |
b2e465d6 AL |
14 | #include <apt-pkg/depcache.h> |
15 | #include <apt-pkg/strutl.h> | |
233b185f | 16 | |
03e39e59 AL |
17 | #include <unistd.h> |
18 | #include <stdlib.h> | |
19 | #include <fcntl.h> | |
090c6566 | 20 | #include <sys/select.h> |
03e39e59 AL |
21 | #include <sys/types.h> |
22 | #include <sys/wait.h> | |
23 | #include <signal.h> | |
24 | #include <errno.h> | |
db0c350f | 25 | #include <stdio.h> |
75ef8f14 MV |
26 | #include <sstream> |
27 | #include <map> | |
28 | ||
d8cb4aa4 MV |
29 | #include <termios.h> |
30 | #include <unistd.h> | |
31 | #include <sys/ioctl.h> | |
32 | #include <pty.h> | |
33 | ||
75ef8f14 MV |
34 | #include <config.h> |
35 | #include <apti18n.h> | |
b0ebdef5 | 36 | /*}}}*/ |
233b185f AL |
37 | |
38 | using namespace std; | |
03e39e59 AL |
39 | |
40 | // DPkgPM::pkgDPkgPM - Constructor /*{{{*/ | |
41 | // --------------------------------------------------------------------- | |
42 | /* */ | |
b2e465d6 | 43 | pkgDPkgPM::pkgDPkgPM(pkgDepCache *Cache) : pkgPackageManager(Cache) |
03e39e59 AL |
44 | { |
45 | } | |
46 | /*}}}*/ | |
47 | // DPkgPM::pkgDPkgPM - Destructor /*{{{*/ | |
48 | // --------------------------------------------------------------------- | |
49 | /* */ | |
50 | pkgDPkgPM::~pkgDPkgPM() | |
51 | { | |
52 | } | |
53 | /*}}}*/ | |
54 | // DPkgPM::Install - Install a package /*{{{*/ | |
55 | // --------------------------------------------------------------------- | |
56 | /* Add an install operation to the sequence list */ | |
57 | bool pkgDPkgPM::Install(PkgIterator Pkg,string File) | |
58 | { | |
59 | if (File.empty() == true || Pkg.end() == true) | |
60 | return _error->Error("Internal Error, No file name for %s",Pkg.Name()); | |
61 | ||
62 | List.push_back(Item(Item::Install,Pkg,File)); | |
63 | return true; | |
64 | } | |
65 | /*}}}*/ | |
66 | // DPkgPM::Configure - Configure a package /*{{{*/ | |
67 | // --------------------------------------------------------------------- | |
68 | /* Add a configure operation to the sequence list */ | |
69 | bool pkgDPkgPM::Configure(PkgIterator Pkg) | |
70 | { | |
71 | if (Pkg.end() == true) | |
72 | return false; | |
73 | ||
74 | List.push_back(Item(Item::Configure,Pkg)); | |
75 | return true; | |
76 | } | |
77 | /*}}}*/ | |
78 | // DPkgPM::Remove - Remove a package /*{{{*/ | |
79 | // --------------------------------------------------------------------- | |
80 | /* Add a remove operation to the sequence list */ | |
fc4b5c9f | 81 | bool pkgDPkgPM::Remove(PkgIterator Pkg,bool Purge) |
03e39e59 AL |
82 | { |
83 | if (Pkg.end() == true) | |
84 | return false; | |
85 | ||
fc4b5c9f AL |
86 | if (Purge == true) |
87 | List.push_back(Item(Item::Purge,Pkg)); | |
88 | else | |
89 | List.push_back(Item(Item::Remove,Pkg)); | |
6dd55be7 AL |
90 | return true; |
91 | } | |
92 | /*}}}*/ | |
93 | // DPkgPM::RunScripts - Run a set of scripts /*{{{*/ | |
94 | // --------------------------------------------------------------------- | |
95 | /* This looks for a list of script sto run from the configuration file, | |
96 | each one is run with system from a forked child. */ | |
97 | bool pkgDPkgPM::RunScripts(const char *Cnf) | |
98 | { | |
99 | Configuration::Item const *Opts = _config->Tree(Cnf); | |
100 | if (Opts == 0 || Opts->Child == 0) | |
101 | return true; | |
102 | Opts = Opts->Child; | |
103 | ||
104 | // Fork for running the system calls | |
54676e1a | 105 | pid_t Child = ExecFork(); |
6dd55be7 AL |
106 | |
107 | // This is the child | |
108 | if (Child == 0) | |
109 | { | |
6dd55be7 AL |
110 | if (chdir("/tmp/") != 0) |
111 | _exit(100); | |
112 | ||
6dd55be7 AL |
113 | unsigned int Count = 1; |
114 | for (; Opts != 0; Opts = Opts->Next, Count++) | |
115 | { | |
116 | if (Opts->Value.empty() == true) | |
117 | continue; | |
118 | ||
119 | if (system(Opts->Value.c_str()) != 0) | |
120 | _exit(100+Count); | |
121 | } | |
122 | _exit(0); | |
123 | } | |
124 | ||
125 | // Wait for the child | |
126 | int Status = 0; | |
127 | while (waitpid(Child,&Status,0) != Child) | |
128 | { | |
129 | if (errno == EINTR) | |
130 | continue; | |
131 | return _error->Errno("waitpid","Couldn't wait for subprocess"); | |
132 | } | |
133 | ||
134 | // Restore sig int/quit | |
135 | signal(SIGQUIT,SIG_DFL); | |
136 | signal(SIGINT,SIG_DFL); | |
ddc1d8d0 | 137 | |
6dd55be7 AL |
138 | // Check for an error code. |
139 | if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0) | |
140 | { | |
141 | unsigned int Count = WEXITSTATUS(Status); | |
142 | if (Count > 100) | |
143 | { | |
144 | Count -= 100; | |
145 | for (; Opts != 0 && Count != 1; Opts = Opts->Next, Count--); | |
cf544e14 | 146 | _error->Error("Problem executing scripts %s '%s'",Cnf,Opts->Value.c_str()); |
6dd55be7 AL |
147 | } |
148 | ||
149 | return _error->Error("Sub-process returned an error code"); | |
150 | } | |
151 | ||
03e39e59 AL |
152 | return true; |
153 | } | |
db0c350f | 154 | /*}}}*/ |
b2e465d6 AL |
155 | // DPkgPM::SendV2Pkgs - Send version 2 package info /*{{{*/ |
156 | // --------------------------------------------------------------------- | |
157 | /* This is part of the helper script communication interface, it sends | |
158 | very complete information down to the other end of the pipe.*/ | |
159 | bool pkgDPkgPM::SendV2Pkgs(FILE *F) | |
160 | { | |
161 | fprintf(F,"VERSION 2\n"); | |
162 | ||
163 | /* Write out all of the configuration directives by walking the | |
164 | configuration tree */ | |
165 | const Configuration::Item *Top = _config->Tree(0); | |
166 | for (; Top != 0;) | |
167 | { | |
168 | if (Top->Value.empty() == false) | |
169 | { | |
170 | fprintf(F,"%s=%s\n", | |
171 | QuoteString(Top->FullTag(),"=\"\n").c_str(), | |
172 | QuoteString(Top->Value,"\n").c_str()); | |
173 | } | |
174 | ||
175 | if (Top->Child != 0) | |
176 | { | |
177 | Top = Top->Child; | |
178 | continue; | |
179 | } | |
180 | ||
181 | while (Top != 0 && Top->Next == 0) | |
182 | Top = Top->Parent; | |
183 | if (Top != 0) | |
184 | Top = Top->Next; | |
185 | } | |
186 | fprintf(F,"\n"); | |
187 | ||
188 | // Write out the package actions in order. | |
189 | for (vector<Item>::iterator I = List.begin(); I != List.end(); I++) | |
190 | { | |
191 | pkgDepCache::StateCache &S = Cache[I->Pkg]; | |
192 | ||
193 | fprintf(F,"%s ",I->Pkg.Name()); | |
194 | // Current version | |
195 | if (I->Pkg->CurrentVer == 0) | |
196 | fprintf(F,"- "); | |
197 | else | |
198 | fprintf(F,"%s ",I->Pkg.CurrentVer().VerStr()); | |
199 | ||
200 | // Show the compare operator | |
201 | // Target version | |
202 | if (S.InstallVer != 0) | |
203 | { | |
204 | int Comp = 2; | |
205 | if (I->Pkg->CurrentVer != 0) | |
206 | Comp = S.InstVerIter(Cache).CompareVer(I->Pkg.CurrentVer()); | |
207 | if (Comp < 0) | |
208 | fprintf(F,"> "); | |
209 | if (Comp == 0) | |
210 | fprintf(F,"= "); | |
211 | if (Comp > 0) | |
212 | fprintf(F,"< "); | |
213 | fprintf(F,"%s ",S.InstVerIter(Cache).VerStr()); | |
214 | } | |
215 | else | |
216 | fprintf(F,"> - "); | |
217 | ||
218 | // Show the filename/operation | |
219 | if (I->Op == Item::Install) | |
220 | { | |
221 | // No errors here.. | |
222 | if (I->File[0] != '/') | |
223 | fprintf(F,"**ERROR**\n"); | |
224 | else | |
225 | fprintf(F,"%s\n",I->File.c_str()); | |
226 | } | |
227 | if (I->Op == Item::Configure) | |
228 | fprintf(F,"**CONFIGURE**\n"); | |
229 | if (I->Op == Item::Remove || | |
230 | I->Op == Item::Purge) | |
231 | fprintf(F,"**REMOVE**\n"); | |
232 | ||
233 | if (ferror(F) != 0) | |
234 | return false; | |
235 | } | |
236 | return true; | |
237 | } | |
238 | /*}}}*/ | |
db0c350f AL |
239 | // DPkgPM::RunScriptsWithPkgs - Run scripts with package names on stdin /*{{{*/ |
240 | // --------------------------------------------------------------------- | |
241 | /* This looks for a list of scripts to run from the configuration file | |
242 | each one is run and is fed on standard input a list of all .deb files | |
243 | that are due to be installed. */ | |
244 | bool pkgDPkgPM::RunScriptsWithPkgs(const char *Cnf) | |
245 | { | |
246 | Configuration::Item const *Opts = _config->Tree(Cnf); | |
247 | if (Opts == 0 || Opts->Child == 0) | |
248 | return true; | |
249 | Opts = Opts->Child; | |
250 | ||
251 | unsigned int Count = 1; | |
252 | for (; Opts != 0; Opts = Opts->Next, Count++) | |
253 | { | |
254 | if (Opts->Value.empty() == true) | |
255 | continue; | |
b2e465d6 AL |
256 | |
257 | // Determine the protocol version | |
258 | string OptSec = Opts->Value; | |
259 | string::size_type Pos; | |
260 | if ((Pos = OptSec.find(' ')) == string::npos || Pos == 0) | |
261 | Pos = OptSec.length(); | |
b2e465d6 AL |
262 | OptSec = "DPkg::Tools::Options::" + string(Opts->Value.c_str(),Pos); |
263 | ||
264 | unsigned int Version = _config->FindI(OptSec+"::Version",1); | |
265 | ||
db0c350f AL |
266 | // Create the pipes |
267 | int Pipes[2]; | |
268 | if (pipe(Pipes) != 0) | |
269 | return _error->Errno("pipe","Failed to create IPC pipe to subprocess"); | |
270 | SetCloseExec(Pipes[0],true); | |
271 | SetCloseExec(Pipes[1],true); | |
272 | ||
273 | // Purified Fork for running the script | |
274 | pid_t Process = ExecFork(); | |
275 | if (Process == 0) | |
276 | { | |
277 | // Setup the FDs | |
278 | dup2(Pipes[0],STDIN_FILENO); | |
279 | SetCloseExec(STDOUT_FILENO,false); | |
280 | SetCloseExec(STDIN_FILENO,false); | |
281 | SetCloseExec(STDERR_FILENO,false); | |
90ecbd7d AL |
282 | |
283 | const char *Args[4]; | |
db0c350f | 284 | Args[0] = "/bin/sh"; |
90ecbd7d AL |
285 | Args[1] = "-c"; |
286 | Args[2] = Opts->Value.c_str(); | |
287 | Args[3] = 0; | |
db0c350f AL |
288 | execv(Args[0],(char **)Args); |
289 | _exit(100); | |
290 | } | |
291 | close(Pipes[0]); | |
b2e465d6 AL |
292 | FILE *F = fdopen(Pipes[1],"w"); |
293 | if (F == 0) | |
294 | return _error->Errno("fdopen","Faild to open new FD"); | |
295 | ||
db0c350f | 296 | // Feed it the filenames. |
b2e465d6 AL |
297 | bool Die = false; |
298 | if (Version <= 1) | |
db0c350f | 299 | { |
b2e465d6 | 300 | for (vector<Item>::iterator I = List.begin(); I != List.end(); I++) |
db0c350f | 301 | { |
b2e465d6 AL |
302 | // Only deal with packages to be installed from .deb |
303 | if (I->Op != Item::Install) | |
304 | continue; | |
305 | ||
306 | // No errors here.. | |
307 | if (I->File[0] != '/') | |
308 | continue; | |
309 | ||
310 | /* Feed the filename of each package that is pending install | |
311 | into the pipe. */ | |
312 | fprintf(F,"%s\n",I->File.c_str()); | |
313 | if (ferror(F) != 0) | |
314 | { | |
315 | Die = true; | |
316 | break; | |
317 | } | |
90ecbd7d | 318 | } |
db0c350f | 319 | } |
b2e465d6 AL |
320 | else |
321 | Die = !SendV2Pkgs(F); | |
322 | ||
323 | fclose(F); | |
db0c350f AL |
324 | |
325 | // Clean up the sub process | |
326 | if (ExecWait(Process,Opts->Value.c_str()) == false) | |
90ecbd7d | 327 | return _error->Error("Failure running script %s",Opts->Value.c_str()); |
db0c350f AL |
328 | } |
329 | ||
330 | return true; | |
331 | } | |
ceabc520 MV |
332 | |
333 | /*}}}*/ | |
334 | // DPkgPM::DoStdin - Read stdin and pass to slave pty /*{{{*/ | |
335 | // --------------------------------------------------------------------- | |
336 | /* | |
337 | */ | |
338 | void pkgDPkgPM::DoStdin(int master) | |
339 | { | |
340 | char input_buf[2] = {0,0}; | |
341 | while(read(0, input_buf, 1) > 0) | |
342 | write(master, input_buf, 1); | |
343 | } | |
03e39e59 | 344 | /*}}}*/ |
ceabc520 MV |
345 | // DPkgPM::DoTerminalPty - Read the terminal pty and write log /*{{{*/ |
346 | // --------------------------------------------------------------------- | |
347 | /* | |
348 | * read the terminal pty and write log | |
349 | */ | |
350 | void pkgDPkgPM::DoTerminalPty(int master, FILE *term_out) | |
351 | { | |
352 | char term_buf[2] = {0,0}; | |
353 | ||
354 | // read a single char, make sure that the read can't block | |
355 | // (otherwise we may leave zombies) | |
356 | do | |
357 | { | |
358 | fwrite(term_buf, 1, 1, term_out); | |
359 | write(1, term_buf, 1); | |
360 | } while(read(master, term_buf, 1) > 0); | |
361 | } | |
362 | /*}}}*/ | |
363 | ||
364 | ||
365 | ||
03e39e59 AL |
366 | // DPkgPM::Go - Run the sequence /*{{{*/ |
367 | // --------------------------------------------------------------------- | |
75ef8f14 MV |
368 | /* This globs the operations and calls dpkg |
369 | * | |
370 | * If it is called with "OutStatusFd" set to a valid file descriptor | |
371 | * apt will report the install progress over this fd. It maps the | |
372 | * dpkg states a package goes through to human readable (and i10n-able) | |
373 | * names and calculates a percentage for each step. | |
374 | */ | |
375 | bool pkgDPkgPM::Go(int OutStatusFd) | |
03e39e59 | 376 | { |
6b8147b8 MZ |
377 | unsigned int MaxArgs = _config->FindI("Dpkg::MaxArgs",8*1024); |
378 | unsigned int MaxArgBytes = _config->FindI("Dpkg::MaxArgBytes",32*1024); | |
aff4e2f1 | 379 | |
6dd55be7 AL |
380 | if (RunScripts("DPkg::Pre-Invoke") == false) |
381 | return false; | |
db0c350f AL |
382 | |
383 | if (RunScriptsWithPkgs("DPkg::Pre-Install-Pkgs") == false) | |
384 | return false; | |
75ef8f14 MV |
385 | |
386 | // prepare the progress reporting | |
387 | int Done = 0; | |
388 | int Total = 0; | |
389 | // map the dpkg states to the operations that are performed | |
390 | // (this is sorted in the same way as Item::Ops) | |
391 | static const struct DpkgState DpkgStatesOpMap[][5] = { | |
392 | // Install operation | |
393 | { | |
21e1008e MV |
394 | {"half-installed", N_("Preparing %s")}, |
395 | {"unpacked", N_("Unpacking %s") }, | |
75ef8f14 MV |
396 | {NULL, NULL} |
397 | }, | |
398 | // Configure operation | |
399 | { | |
21e1008e MV |
400 | {"unpacked",N_("Preparing to configure %s") }, |
401 | {"half-configured", N_("Configuring %s") }, | |
402 | { "installed", N_("Installed %s")}, | |
75ef8f14 MV |
403 | {NULL, NULL} |
404 | }, | |
405 | // Remove operation | |
406 | { | |
21e1008e MV |
407 | {"half-configured", N_("Preparing for removal of %s")}, |
408 | {"half-installed", N_("Removing %s")}, | |
409 | {"config-files", N_("Removed %s")}, | |
75ef8f14 MV |
410 | {NULL, NULL} |
411 | }, | |
412 | // Purge operation | |
413 | { | |
21e1008e MV |
414 | {"config-files", N_("Preparing to completely remove %s")}, |
415 | {"not-installed", N_("Completely removed %s")}, | |
75ef8f14 MV |
416 | {NULL, NULL} |
417 | }, | |
418 | }; | |
db0c350f | 419 | |
75ef8f14 MV |
420 | // the dpkg states that the pkg will run through, the string is |
421 | // the package, the vector contains the dpkg states that the package | |
422 | // will go through | |
423 | map<string,vector<struct DpkgState> > PackageOps; | |
424 | // the dpkg states that are already done; the string is the package | |
425 | // the int is the state that is already done (e.g. a package that is | |
426 | // going to be install is already in state "half-installed") | |
427 | map<string,int> PackageOpsDone; | |
428 | ||
429 | // init the PackageOps map, go over the list of packages that | |
430 | // that will be [installed|configured|removed|purged] and add | |
431 | // them to the PackageOps map (the dpkg states it goes through) | |
432 | // and the PackageOpsTranslations (human readable strings) | |
433 | for (vector<Item>::iterator I = List.begin(); I != List.end();I++) | |
434 | { | |
435 | string name = (*I).Pkg.Name(); | |
436 | PackageOpsDone[name] = 0; | |
437 | for(int i=0; (DpkgStatesOpMap[(*I).Op][i]).state != NULL; i++) | |
438 | { | |
439 | PackageOps[name].push_back(DpkgStatesOpMap[(*I).Op][i]); | |
440 | Total++; | |
441 | } | |
442 | } | |
443 | ||
444 | // this loop is runs once per operation | |
03e39e59 AL |
445 | for (vector<Item>::iterator I = List.begin(); I != List.end();) |
446 | { | |
447 | vector<Item>::iterator J = I; | |
448 | for (; J != List.end() && J->Op == I->Op; J++); | |
30e1eab5 | 449 | |
03e39e59 | 450 | // Generate the argument list |
aff4e2f1 AL |
451 | const char *Args[MaxArgs + 50]; |
452 | if (J - I > (signed)MaxArgs) | |
453 | J = I + MaxArgs; | |
03e39e59 | 454 | |
30e1eab5 AL |
455 | unsigned int n = 0; |
456 | unsigned long Size = 0; | |
43b3b626 | 457 | string Tmp = _config->Find("Dir::Bin::dpkg","dpkg"); |
50914ffa | 458 | Args[n++] = Tmp.c_str(); |
30e1eab5 | 459 | Size += strlen(Args[n-1]); |
03e39e59 | 460 | |
6dd55be7 AL |
461 | // Stick in any custom dpkg options |
462 | Configuration::Item const *Opts = _config->Tree("DPkg::Options"); | |
463 | if (Opts != 0) | |
464 | { | |
465 | Opts = Opts->Child; | |
466 | for (; Opts != 0; Opts = Opts->Next) | |
467 | { | |
468 | if (Opts->Value.empty() == true) | |
469 | continue; | |
470 | Args[n++] = Opts->Value.c_str(); | |
471 | Size += Opts->Value.length(); | |
472 | } | |
473 | } | |
474 | ||
007dc9e0 | 475 | char status_fd_buf[20]; |
75ef8f14 MV |
476 | int fd[2]; |
477 | pipe(fd); | |
478 | ||
479 | Args[n++] = "--status-fd"; | |
480 | Size += strlen(Args[n-1]); | |
481 | snprintf(status_fd_buf,sizeof(status_fd_buf),"%i", fd[1]); | |
482 | Args[n++] = status_fd_buf; | |
483 | Size += strlen(Args[n-1]); | |
007dc9e0 | 484 | |
03e39e59 AL |
485 | switch (I->Op) |
486 | { | |
487 | case Item::Remove: | |
488 | Args[n++] = "--force-depends"; | |
30e1eab5 | 489 | Size += strlen(Args[n-1]); |
03e39e59 | 490 | Args[n++] = "--force-remove-essential"; |
30e1eab5 | 491 | Size += strlen(Args[n-1]); |
03e39e59 | 492 | Args[n++] = "--remove"; |
30e1eab5 | 493 | Size += strlen(Args[n-1]); |
03e39e59 AL |
494 | break; |
495 | ||
fc4b5c9f AL |
496 | case Item::Purge: |
497 | Args[n++] = "--force-depends"; | |
498 | Size += strlen(Args[n-1]); | |
499 | Args[n++] = "--force-remove-essential"; | |
500 | Size += strlen(Args[n-1]); | |
501 | Args[n++] = "--purge"; | |
502 | Size += strlen(Args[n-1]); | |
503 | break; | |
504 | ||
03e39e59 AL |
505 | case Item::Configure: |
506 | Args[n++] = "--configure"; | |
30e1eab5 | 507 | Size += strlen(Args[n-1]); |
03e39e59 AL |
508 | break; |
509 | ||
510 | case Item::Install: | |
511 | Args[n++] = "--unpack"; | |
30e1eab5 | 512 | Size += strlen(Args[n-1]); |
857a1d4a MV |
513 | Args[n++] = "--auto-deconfigure"; |
514 | Size += strlen(Args[n-1]); | |
03e39e59 AL |
515 | break; |
516 | } | |
517 | ||
518 | // Write in the file or package names | |
519 | if (I->Op == Item::Install) | |
30e1eab5 | 520 | { |
aff4e2f1 | 521 | for (;I != J && Size < MaxArgBytes; I++) |
30e1eab5 | 522 | { |
cf544e14 AL |
523 | if (I->File[0] != '/') |
524 | return _error->Error("Internal Error, Pathname to install is not absolute '%s'",I->File.c_str()); | |
03e39e59 | 525 | Args[n++] = I->File.c_str(); |
30e1eab5 AL |
526 | Size += strlen(Args[n-1]); |
527 | } | |
528 | } | |
03e39e59 | 529 | else |
30e1eab5 | 530 | { |
aff4e2f1 | 531 | for (;I != J && Size < MaxArgBytes; I++) |
30e1eab5 | 532 | { |
03e39e59 | 533 | Args[n++] = I->Pkg.Name(); |
30e1eab5 AL |
534 | Size += strlen(Args[n-1]); |
535 | } | |
536 | } | |
03e39e59 | 537 | Args[n] = 0; |
30e1eab5 AL |
538 | J = I; |
539 | ||
540 | if (_config->FindB("Debug::pkgDPkgPM",false) == true) | |
541 | { | |
542 | for (unsigned int k = 0; k != n; k++) | |
543 | clog << Args[k] << ' '; | |
544 | clog << endl; | |
545 | continue; | |
546 | } | |
03e39e59 | 547 | |
03e39e59 AL |
548 | cout << flush; |
549 | clog << flush; | |
550 | cerr << flush; | |
551 | ||
552 | /* Mask off sig int/quit. We do this because dpkg also does when | |
553 | it forks scripts. What happens is that when you hit ctrl-c it sends | |
554 | it to all processes in the group. Since dpkg ignores the signal | |
555 | it doesn't die but we do! So we must also ignore it */ | |
7f9a6360 AL |
556 | sighandler_t old_SIGQUIT = signal(SIGQUIT,SIG_IGN); |
557 | sighandler_t old_SIGINT = signal(SIGINT,SIG_IGN); | |
d8cb4aa4 MV |
558 | |
559 | struct termios tt; | |
560 | struct winsize win; | |
561 | int master; | |
562 | int slave; | |
563 | ||
ceabc520 | 564 | // FIXME: setup sensible signal handling (*ick*) |
d8cb4aa4 MV |
565 | tcgetattr(0, &tt); |
566 | ioctl(0, TIOCGWINSZ, (char *)&win); | |
090c6566 MV |
567 | if (openpty(&master, &slave, NULL, &tt, &win) < 0) |
568 | { | |
d8cb4aa4 MV |
569 | fprintf(stderr, _("openpty failed\n")); |
570 | } | |
571 | ||
572 | struct termios rtt; | |
573 | rtt = tt; | |
574 | cfmakeraw(&rtt); | |
575 | rtt.c_lflag &= ~ECHO; | |
576 | tcsetattr(0, TCSAFLUSH, &rtt); | |
577 | ||
75ef8f14 | 578 | // Fork dpkg |
007dc9e0 | 579 | pid_t Child; |
75ef8f14 MV |
580 | _config->Set("APT::Keep-Fds::",fd[1]); |
581 | Child = ExecFork(); | |
6dd55be7 | 582 | |
03e39e59 AL |
583 | // This is the child |
584 | if (Child == 0) | |
585 | { | |
d8cb4aa4 MV |
586 | setsid(); |
587 | ioctl(slave, TIOCSCTTY, 0); | |
588 | close(master); | |
589 | dup2(slave, 0); | |
590 | dup2(slave, 1); | |
591 | dup2(slave, 2); | |
592 | close(slave); | |
593 | ||
75ef8f14 | 594 | close(fd[0]); // close the read end of the pipe |
d8cb4aa4 | 595 | |
cf544e14 | 596 | if (chdir(_config->FindDir("DPkg::Run-Directory","/").c_str()) != 0) |
0dbb95d8 | 597 | _exit(100); |
03e39e59 | 598 | |
421ff807 | 599 | if (_config->FindB("DPkg::FlushSTDIN",true) == true && isatty(STDIN_FILENO)) |
8b5fe26c AL |
600 | { |
601 | int Flags,dummy; | |
602 | if ((Flags = fcntl(STDIN_FILENO,F_GETFL,dummy)) < 0) | |
603 | _exit(100); | |
604 | ||
605 | // Discard everything in stdin before forking dpkg | |
606 | if (fcntl(STDIN_FILENO,F_SETFL,Flags | O_NONBLOCK) < 0) | |
607 | _exit(100); | |
608 | ||
609 | while (read(STDIN_FILENO,&dummy,1) == 1); | |
610 | ||
611 | if (fcntl(STDIN_FILENO,F_SETFL,Flags & (~(long)O_NONBLOCK)) < 0) | |
612 | _exit(100); | |
613 | } | |
d8cb4aa4 MV |
614 | |
615 | ||
03e39e59 AL |
616 | /* No Job Control Stop Env is a magic dpkg var that prevents it |
617 | from using sigstop */ | |
101030ab | 618 | putenv("DPKG_NO_TSTP=yes"); |
d568ed2d | 619 | execvp(Args[0],(char **)Args); |
03e39e59 | 620 | cerr << "Could not exec dpkg!" << endl; |
0dbb95d8 | 621 | _exit(100); |
03e39e59 AL |
622 | } |
623 | ||
75ef8f14 MV |
624 | // clear the Keep-Fd again |
625 | _config->Clear("APT::Keep-Fds",fd[1]); | |
626 | ||
03e39e59 AL |
627 | // Wait for dpkg |
628 | int Status = 0; | |
75ef8f14 MV |
629 | |
630 | // we read from dpkg here | |
631 | int _dpkgin = fd[0]; | |
632 | fcntl(_dpkgin, F_SETFL, O_NONBLOCK); | |
633 | close(fd[1]); // close the write end of the pipe | |
634 | ||
635 | // the read buffers for the communication with dpkg | |
636 | char line[1024] = {0,}; | |
d8cb4aa4 | 637 | |
75ef8f14 MV |
638 | char buf[2] = {0,0}; |
639 | ||
640 | // the result of the waitpid call | |
641 | int res; | |
d8cb4aa4 MV |
642 | close(slave); |
643 | fcntl(0, F_SETFL, O_NONBLOCK); | |
644 | fcntl(master, F_SETFL, O_NONBLOCK); | |
090c6566 | 645 | // FIXME: make this a apt config option and add a logrotate file |
d8cb4aa4 MV |
646 | FILE *term_out = fopen("/var/log/dpkg-out.log","a"); |
647 | chmod("/var/log/dpkg-out.log", 0600); | |
090c6566 MV |
648 | |
649 | fd_set rfds; | |
650 | struct timeval tv; | |
651 | int select_ret; | |
652 | FD_ZERO(&rfds); | |
653 | FD_SET(0, &rfds); | |
654 | FD_SET(_dpkgin, &rfds); | |
655 | FD_SET(master, &rfds); | |
75ef8f14 MV |
656 | while ((res=waitpid(Child,&Status, WNOHANG)) != Child) { |
657 | if(res < 0) { | |
658 | // FIXME: move this to a function or something, looks ugly here | |
659 | // error handling, waitpid returned -1 | |
660 | if (errno == EINTR) | |
661 | continue; | |
662 | RunScripts("DPkg::Post-Invoke"); | |
663 | ||
664 | // Restore sig int/quit | |
665 | signal(SIGQUIT,old_SIGQUIT); | |
666 | signal(SIGINT,old_SIGINT); | |
667 | return _error->Errno("waitpid","Couldn't wait for subprocess"); | |
668 | } | |
d8cb4aa4 MV |
669 | |
670 | // wait for input or output here | |
090c6566 MV |
671 | tv.tv_sec = 1; |
672 | tv.tv_usec = 0; | |
673 | select_ret = select(max(master, _dpkgin)+1, &rfds, NULL, &rfds, &tv); | |
674 | if (select_ret < 0) | |
675 | std::cerr << "Error in select()" << std::endl; | |
676 | else if (select_ret == 0) | |
677 | continue; | |
678 | ||
ceabc520 MV |
679 | DoStdin(master); |
680 | DoTerminalPty(master, term_out); | |
681 | //DoDpkgStatusFd(); | |
75ef8f14 | 682 | |
ceabc520 | 683 | int len = read(_dpkgin, buf, 1); |
d8cb4aa4 MV |
684 | |
685 | // nothing to read from dpkg , wait a bit for more | |
75ef8f14 MV |
686 | if(len <= 0) |
687 | { | |
688 | usleep(1000); | |
03e39e59 | 689 | continue; |
75ef8f14 | 690 | } |
d8cb4aa4 | 691 | |
75ef8f14 MV |
692 | // sanity check (should never happen) |
693 | if(strlen(line) >= sizeof(line)-10) | |
694 | { | |
695 | _error->Error("got a overlong line from dpkg: '%s'",line); | |
696 | line[0]=0; | |
697 | } | |
698 | // append to line, check if we got a complete line | |
699 | strcat(line, buf); | |
700 | if(buf[0] != '\n') | |
701 | continue; | |
702 | ||
703 | if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true) | |
704 | std::clog << "got from dpkg '" << line << "'" << std::endl; | |
705 | ||
706 | // the status we output | |
707 | ostringstream status; | |
708 | ||
709 | /* dpkg sends strings like this: | |
710 | 'status: <pkg>: <pkg qstate>' | |
711 | errors look like this: | |
712 | '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 | |
713 | and conffile-prompt like this | |
714 | 'status: conffile-prompt: conffile : 'current-conffile' 'new-conffile' useredited distedited | |
715 | ||
716 | */ | |
eda1bb3c | 717 | char* list[5]; |
ed94a0d6 MV |
718 | // dpkg sends multiline error messages sometimes (see |
719 | // #374195 for a example. we should support this by | |
720 | // either patching dpkg to not send multiline over the | |
721 | // statusfd or by rewriting the code here to deal with | |
722 | // it. for now we just ignore it and not crash | |
723 | TokSplitString(':', line, list, sizeof(list)/sizeof(list[0])); | |
75ef8f14 MV |
724 | char *pkg = list[1]; |
725 | char *action = _strstrip(list[2]); | |
ed94a0d6 MV |
726 | if( pkg == NULL || action == NULL) |
727 | { | |
728 | if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true) | |
729 | std::clog << "ignoring line: not enough ':'" << std::endl; | |
7882f8fe MV |
730 | // reset the line buffer |
731 | line[0]=0; | |
ed94a0d6 MV |
732 | continue; |
733 | } | |
75ef8f14 MV |
734 | |
735 | if(strncmp(action,"error",strlen("error")) == 0) | |
736 | { | |
737 | status << "pmerror:" << list[1] | |
738 | << ":" << (Done/float(Total)*100.0) | |
739 | << ":" << list[3] | |
740 | << endl; | |
741 | if(OutStatusFd > 0) | |
742 | write(OutStatusFd, status.str().c_str(), status.str().size()); | |
743 | line[0]=0; | |
744 | if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true) | |
745 | std::clog << "send: '" << status.str() << "'" << endl; | |
746 | continue; | |
747 | } | |
748 | if(strncmp(action,"conffile",strlen("conffile")) == 0) | |
749 | { | |
750 | status << "pmconffile:" << list[1] | |
751 | << ":" << (Done/float(Total)*100.0) | |
752 | << ":" << list[3] | |
753 | << endl; | |
754 | if(OutStatusFd > 0) | |
755 | write(OutStatusFd, status.str().c_str(), status.str().size()); | |
756 | line[0]=0; | |
757 | if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true) | |
758 | std::clog << "send: '" << status.str() << "'" << endl; | |
759 | continue; | |
760 | } | |
761 | ||
762 | vector<struct DpkgState> &states = PackageOps[pkg]; | |
763 | const char *next_action = NULL; | |
764 | if(PackageOpsDone[pkg] < states.size()) | |
765 | next_action = states[PackageOpsDone[pkg]].state; | |
766 | // check if the package moved to the next dpkg state | |
767 | if(next_action && (strcmp(action, next_action) == 0)) | |
768 | { | |
769 | // only read the translation if there is actually a next | |
770 | // action | |
21e1008e | 771 | const char *translation = _(states[PackageOpsDone[pkg]].str); |
75ef8f14 MV |
772 | char s[200]; |
773 | snprintf(s, sizeof(s), translation, pkg); | |
774 | ||
775 | // we moved from one dpkg state to a new one, report that | |
776 | PackageOpsDone[pkg]++; | |
777 | Done++; | |
778 | // build the status str | |
779 | status << "pmstatus:" << pkg | |
780 | << ":" << (Done/float(Total)*100.0) | |
781 | << ":" << s | |
782 | << endl; | |
783 | if(OutStatusFd > 0) | |
784 | write(OutStatusFd, status.str().c_str(), status.str().size()); | |
785 | if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true) | |
786 | std::clog << "send: '" << status.str() << "'" << endl; | |
787 | ||
788 | } | |
789 | if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true) | |
790 | std::clog << "(parsed from dpkg) pkg: " << pkg | |
791 | << " action: " << action << endl; | |
7f9a6360 | 792 | |
75ef8f14 MV |
793 | // reset the line buffer |
794 | line[0]=0; | |
03e39e59 | 795 | } |
75ef8f14 | 796 | close(_dpkgin); |
d8cb4aa4 | 797 | fclose(term_out); |
03e39e59 AL |
798 | |
799 | // Restore sig int/quit | |
7f9a6360 AL |
800 | signal(SIGQUIT,old_SIGQUIT); |
801 | signal(SIGINT,old_SIGINT); | |
d8cb4aa4 MV |
802 | |
803 | tcsetattr(0, TCSAFLUSH, &tt); | |
6dd55be7 AL |
804 | |
805 | // Check for an error code. | |
806 | if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0) | |
807 | { | |
c70496f9 MV |
808 | // if it was set to "keep-dpkg-runing" then we won't return |
809 | // here but keep the loop going and just report it as a error | |
810 | // for later | |
811 | bool stopOnError = _config->FindB("Dpkg::StopOnError",true); | |
f956efb4 | 812 | |
c70496f9 MV |
813 | if(stopOnError) |
814 | RunScripts("DPkg::Post-Invoke"); | |
815 | ||
816 | if (WIFSIGNALED(Status) != 0 && WTERMSIG(Status) == SIGSEGV) | |
817 | _error->Error("Sub-process %s received a segmentation fault.",Args[0]); | |
818 | else if (WIFEXITED(Status) != 0) | |
819 | _error->Error("Sub-process %s returned an error code (%u)",Args[0],WEXITSTATUS(Status)); | |
820 | else | |
821 | _error->Error("Sub-process %s exited unexpectedly",Args[0]); | |
822 | ||
823 | if(stopOnError) | |
824 | return false; | |
6dd55be7 | 825 | } |
03e39e59 | 826 | } |
6dd55be7 AL |
827 | |
828 | if (RunScripts("DPkg::Post-Invoke") == false) | |
829 | return false; | |
03e39e59 AL |
830 | return true; |
831 | } | |
832 | /*}}}*/ | |
281daf46 AL |
833 | // pkgDpkgPM::Reset - Dump the contents of the command list /*{{{*/ |
834 | // --------------------------------------------------------------------- | |
835 | /* */ | |
836 | void pkgDPkgPM::Reset() | |
837 | { | |
838 | List.erase(List.begin(),List.end()); | |
839 | } | |
840 | /*}}}*/ |