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 | { | |
955a6ddb MV |
340 | char input_buf[256] = {0,}; |
341 | int len = read(0, input_buf, sizeof(input_buf)); | |
342 | write(master, input_buf, len); | |
ceabc520 | 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 | { | |
955a6ddb | 352 | char term_buf[1024] = {0,}; |
ceabc520 | 353 | |
955a6ddb MV |
354 | int len=read(master, term_buf, sizeof(term_buf)); |
355 | if(len <= 0) | |
356 | return; | |
357 | fwrite(term_buf, len, sizeof(char), term_out); | |
358 | write(1, term_buf, len); | |
ceabc520 | 359 | } |
03e39e59 | 360 | /*}}}*/ |
ceabc520 MV |
361 | |
362 | ||
363 | ||
03e39e59 AL |
364 | // DPkgPM::Go - Run the sequence /*{{{*/ |
365 | // --------------------------------------------------------------------- | |
75ef8f14 MV |
366 | /* This globs the operations and calls dpkg |
367 | * | |
368 | * If it is called with "OutStatusFd" set to a valid file descriptor | |
369 | * apt will report the install progress over this fd. It maps the | |
370 | * dpkg states a package goes through to human readable (and i10n-able) | |
371 | * names and calculates a percentage for each step. | |
372 | */ | |
373 | bool pkgDPkgPM::Go(int OutStatusFd) | |
03e39e59 | 374 | { |
6b8147b8 MZ |
375 | unsigned int MaxArgs = _config->FindI("Dpkg::MaxArgs",8*1024); |
376 | unsigned int MaxArgBytes = _config->FindI("Dpkg::MaxArgBytes",32*1024); | |
aff4e2f1 | 377 | |
6dd55be7 AL |
378 | if (RunScripts("DPkg::Pre-Invoke") == false) |
379 | return false; | |
db0c350f AL |
380 | |
381 | if (RunScriptsWithPkgs("DPkg::Pre-Install-Pkgs") == false) | |
382 | return false; | |
75ef8f14 MV |
383 | |
384 | // prepare the progress reporting | |
385 | int Done = 0; | |
386 | int Total = 0; | |
387 | // map the dpkg states to the operations that are performed | |
388 | // (this is sorted in the same way as Item::Ops) | |
389 | static const struct DpkgState DpkgStatesOpMap[][5] = { | |
390 | // Install operation | |
391 | { | |
21e1008e MV |
392 | {"half-installed", N_("Preparing %s")}, |
393 | {"unpacked", N_("Unpacking %s") }, | |
75ef8f14 MV |
394 | {NULL, NULL} |
395 | }, | |
396 | // Configure operation | |
397 | { | |
21e1008e MV |
398 | {"unpacked",N_("Preparing to configure %s") }, |
399 | {"half-configured", N_("Configuring %s") }, | |
400 | { "installed", N_("Installed %s")}, | |
75ef8f14 MV |
401 | {NULL, NULL} |
402 | }, | |
403 | // Remove operation | |
404 | { | |
21e1008e MV |
405 | {"half-configured", N_("Preparing for removal of %s")}, |
406 | {"half-installed", N_("Removing %s")}, | |
407 | {"config-files", N_("Removed %s")}, | |
75ef8f14 MV |
408 | {NULL, NULL} |
409 | }, | |
410 | // Purge operation | |
411 | { | |
21e1008e MV |
412 | {"config-files", N_("Preparing to completely remove %s")}, |
413 | {"not-installed", N_("Completely removed %s")}, | |
75ef8f14 MV |
414 | {NULL, NULL} |
415 | }, | |
416 | }; | |
db0c350f | 417 | |
75ef8f14 MV |
418 | // the dpkg states that the pkg will run through, the string is |
419 | // the package, the vector contains the dpkg states that the package | |
420 | // will go through | |
421 | map<string,vector<struct DpkgState> > PackageOps; | |
422 | // the dpkg states that are already done; the string is the package | |
423 | // the int is the state that is already done (e.g. a package that is | |
424 | // going to be install is already in state "half-installed") | |
425 | map<string,int> PackageOpsDone; | |
426 | ||
427 | // init the PackageOps map, go over the list of packages that | |
428 | // that will be [installed|configured|removed|purged] and add | |
429 | // them to the PackageOps map (the dpkg states it goes through) | |
430 | // and the PackageOpsTranslations (human readable strings) | |
431 | for (vector<Item>::iterator I = List.begin(); I != List.end();I++) | |
432 | { | |
433 | string name = (*I).Pkg.Name(); | |
434 | PackageOpsDone[name] = 0; | |
435 | for(int i=0; (DpkgStatesOpMap[(*I).Op][i]).state != NULL; i++) | |
436 | { | |
437 | PackageOps[name].push_back(DpkgStatesOpMap[(*I).Op][i]); | |
438 | Total++; | |
439 | } | |
440 | } | |
441 | ||
442 | // this loop is runs once per operation | |
03e39e59 AL |
443 | for (vector<Item>::iterator I = List.begin(); I != List.end();) |
444 | { | |
445 | vector<Item>::iterator J = I; | |
446 | for (; J != List.end() && J->Op == I->Op; J++); | |
30e1eab5 | 447 | |
03e39e59 | 448 | // Generate the argument list |
aff4e2f1 AL |
449 | const char *Args[MaxArgs + 50]; |
450 | if (J - I > (signed)MaxArgs) | |
451 | J = I + MaxArgs; | |
03e39e59 | 452 | |
30e1eab5 AL |
453 | unsigned int n = 0; |
454 | unsigned long Size = 0; | |
43b3b626 | 455 | string Tmp = _config->Find("Dir::Bin::dpkg","dpkg"); |
50914ffa | 456 | Args[n++] = Tmp.c_str(); |
30e1eab5 | 457 | Size += strlen(Args[n-1]); |
03e39e59 | 458 | |
6dd55be7 AL |
459 | // Stick in any custom dpkg options |
460 | Configuration::Item const *Opts = _config->Tree("DPkg::Options"); | |
461 | if (Opts != 0) | |
462 | { | |
463 | Opts = Opts->Child; | |
464 | for (; Opts != 0; Opts = Opts->Next) | |
465 | { | |
466 | if (Opts->Value.empty() == true) | |
467 | continue; | |
468 | Args[n++] = Opts->Value.c_str(); | |
469 | Size += Opts->Value.length(); | |
470 | } | |
471 | } | |
472 | ||
007dc9e0 | 473 | char status_fd_buf[20]; |
75ef8f14 MV |
474 | int fd[2]; |
475 | pipe(fd); | |
476 | ||
477 | Args[n++] = "--status-fd"; | |
478 | Size += strlen(Args[n-1]); | |
479 | snprintf(status_fd_buf,sizeof(status_fd_buf),"%i", fd[1]); | |
480 | Args[n++] = status_fd_buf; | |
481 | Size += strlen(Args[n-1]); | |
007dc9e0 | 482 | |
03e39e59 AL |
483 | switch (I->Op) |
484 | { | |
485 | case Item::Remove: | |
486 | Args[n++] = "--force-depends"; | |
30e1eab5 | 487 | Size += strlen(Args[n-1]); |
03e39e59 | 488 | Args[n++] = "--force-remove-essential"; |
30e1eab5 | 489 | Size += strlen(Args[n-1]); |
03e39e59 | 490 | Args[n++] = "--remove"; |
30e1eab5 | 491 | Size += strlen(Args[n-1]); |
03e39e59 AL |
492 | break; |
493 | ||
fc4b5c9f AL |
494 | case Item::Purge: |
495 | Args[n++] = "--force-depends"; | |
496 | Size += strlen(Args[n-1]); | |
497 | Args[n++] = "--force-remove-essential"; | |
498 | Size += strlen(Args[n-1]); | |
499 | Args[n++] = "--purge"; | |
500 | Size += strlen(Args[n-1]); | |
501 | break; | |
502 | ||
03e39e59 AL |
503 | case Item::Configure: |
504 | Args[n++] = "--configure"; | |
30e1eab5 | 505 | Size += strlen(Args[n-1]); |
03e39e59 AL |
506 | break; |
507 | ||
508 | case Item::Install: | |
509 | Args[n++] = "--unpack"; | |
30e1eab5 | 510 | Size += strlen(Args[n-1]); |
857a1d4a MV |
511 | Args[n++] = "--auto-deconfigure"; |
512 | Size += strlen(Args[n-1]); | |
03e39e59 AL |
513 | break; |
514 | } | |
515 | ||
516 | // Write in the file or package names | |
517 | if (I->Op == Item::Install) | |
30e1eab5 | 518 | { |
aff4e2f1 | 519 | for (;I != J && Size < MaxArgBytes; I++) |
30e1eab5 | 520 | { |
cf544e14 AL |
521 | if (I->File[0] != '/') |
522 | return _error->Error("Internal Error, Pathname to install is not absolute '%s'",I->File.c_str()); | |
03e39e59 | 523 | Args[n++] = I->File.c_str(); |
30e1eab5 AL |
524 | Size += strlen(Args[n-1]); |
525 | } | |
526 | } | |
03e39e59 | 527 | else |
30e1eab5 | 528 | { |
aff4e2f1 | 529 | for (;I != J && Size < MaxArgBytes; I++) |
30e1eab5 | 530 | { |
03e39e59 | 531 | Args[n++] = I->Pkg.Name(); |
30e1eab5 AL |
532 | Size += strlen(Args[n-1]); |
533 | } | |
534 | } | |
03e39e59 | 535 | Args[n] = 0; |
30e1eab5 AL |
536 | J = I; |
537 | ||
538 | if (_config->FindB("Debug::pkgDPkgPM",false) == true) | |
539 | { | |
540 | for (unsigned int k = 0; k != n; k++) | |
541 | clog << Args[k] << ' '; | |
542 | clog << endl; | |
543 | continue; | |
544 | } | |
03e39e59 | 545 | |
03e39e59 AL |
546 | cout << flush; |
547 | clog << flush; | |
548 | cerr << flush; | |
549 | ||
550 | /* Mask off sig int/quit. We do this because dpkg also does when | |
551 | it forks scripts. What happens is that when you hit ctrl-c it sends | |
552 | it to all processes in the group. Since dpkg ignores the signal | |
553 | it doesn't die but we do! So we must also ignore it */ | |
7f9a6360 AL |
554 | sighandler_t old_SIGQUIT = signal(SIGQUIT,SIG_IGN); |
555 | sighandler_t old_SIGINT = signal(SIGINT,SIG_IGN); | |
d8cb4aa4 MV |
556 | |
557 | struct termios tt; | |
558 | struct winsize win; | |
559 | int master; | |
560 | int slave; | |
561 | ||
ceabc520 | 562 | // FIXME: setup sensible signal handling (*ick*) |
d8cb4aa4 MV |
563 | tcgetattr(0, &tt); |
564 | ioctl(0, TIOCGWINSZ, (char *)&win); | |
090c6566 MV |
565 | if (openpty(&master, &slave, NULL, &tt, &win) < 0) |
566 | { | |
d8cb4aa4 MV |
567 | fprintf(stderr, _("openpty failed\n")); |
568 | } | |
569 | ||
570 | struct termios rtt; | |
571 | rtt = tt; | |
572 | cfmakeraw(&rtt); | |
573 | rtt.c_lflag &= ~ECHO; | |
574 | tcsetattr(0, TCSAFLUSH, &rtt); | |
575 | ||
75ef8f14 | 576 | // Fork dpkg |
007dc9e0 | 577 | pid_t Child; |
75ef8f14 MV |
578 | _config->Set("APT::Keep-Fds::",fd[1]); |
579 | Child = ExecFork(); | |
6dd55be7 | 580 | |
03e39e59 AL |
581 | // This is the child |
582 | if (Child == 0) | |
583 | { | |
d8cb4aa4 MV |
584 | setsid(); |
585 | ioctl(slave, TIOCSCTTY, 0); | |
586 | close(master); | |
587 | dup2(slave, 0); | |
588 | dup2(slave, 1); | |
589 | dup2(slave, 2); | |
590 | close(slave); | |
75ef8f14 | 591 | close(fd[0]); // close the read end of the pipe |
d8cb4aa4 | 592 | |
cf544e14 | 593 | if (chdir(_config->FindDir("DPkg::Run-Directory","/").c_str()) != 0) |
0dbb95d8 | 594 | _exit(100); |
03e39e59 | 595 | |
421ff807 | 596 | if (_config->FindB("DPkg::FlushSTDIN",true) == true && isatty(STDIN_FILENO)) |
8b5fe26c AL |
597 | { |
598 | int Flags,dummy; | |
599 | if ((Flags = fcntl(STDIN_FILENO,F_GETFL,dummy)) < 0) | |
600 | _exit(100); | |
601 | ||
602 | // Discard everything in stdin before forking dpkg | |
603 | if (fcntl(STDIN_FILENO,F_SETFL,Flags | O_NONBLOCK) < 0) | |
604 | _exit(100); | |
605 | ||
606 | while (read(STDIN_FILENO,&dummy,1) == 1); | |
607 | ||
608 | if (fcntl(STDIN_FILENO,F_SETFL,Flags & (~(long)O_NONBLOCK)) < 0) | |
609 | _exit(100); | |
610 | } | |
d8cb4aa4 MV |
611 | |
612 | ||
03e39e59 AL |
613 | /* No Job Control Stop Env is a magic dpkg var that prevents it |
614 | from using sigstop */ | |
101030ab | 615 | putenv("DPKG_NO_TSTP=yes"); |
d568ed2d | 616 | execvp(Args[0],(char **)Args); |
03e39e59 | 617 | cerr << "Could not exec dpkg!" << endl; |
0dbb95d8 | 618 | _exit(100); |
03e39e59 AL |
619 | } |
620 | ||
75ef8f14 MV |
621 | // clear the Keep-Fd again |
622 | _config->Clear("APT::Keep-Fds",fd[1]); | |
623 | ||
03e39e59 AL |
624 | // Wait for dpkg |
625 | int Status = 0; | |
75ef8f14 MV |
626 | |
627 | // we read from dpkg here | |
628 | int _dpkgin = fd[0]; | |
629 | fcntl(_dpkgin, F_SETFL, O_NONBLOCK); | |
630 | close(fd[1]); // close the write end of the pipe | |
631 | ||
632 | // the read buffers for the communication with dpkg | |
633 | char line[1024] = {0,}; | |
634 | char buf[2] = {0,0}; | |
635 | ||
636 | // the result of the waitpid call | |
637 | int res; | |
d8cb4aa4 | 638 | close(slave); |
955a6ddb | 639 | #if 0 |
d8cb4aa4 MV |
640 | fcntl(0, F_SETFL, O_NONBLOCK); |
641 | fcntl(master, F_SETFL, O_NONBLOCK); | |
955a6ddb | 642 | #endif |
090c6566 | 643 | // FIXME: make this a apt config option and add a logrotate file |
d8cb4aa4 MV |
644 | FILE *term_out = fopen("/var/log/dpkg-out.log","a"); |
645 | chmod("/var/log/dpkg-out.log", 0600); | |
97efd303 MV |
646 | // output current time |
647 | char outstr[200]; | |
648 | time_t t = time(NULL); | |
649 | struct tm *tmp = localtime(&t); | |
650 | strftime(outstr, sizeof(outstr), "%F %T", tmp); | |
651 | fprintf(term_out, "Log started: "); | |
652 | fprintf(term_out, outstr); | |
653 | fprintf(term_out, "\n"); | |
654 | ||
655 | // setups fds | |
090c6566 MV |
656 | fd_set rfds; |
657 | struct timeval tv; | |
658 | int select_ret; | |
75ef8f14 MV |
659 | while ((res=waitpid(Child,&Status, WNOHANG)) != Child) { |
660 | if(res < 0) { | |
661 | // FIXME: move this to a function or something, looks ugly here | |
662 | // error handling, waitpid returned -1 | |
663 | if (errno == EINTR) | |
664 | continue; | |
665 | RunScripts("DPkg::Post-Invoke"); | |
666 | ||
667 | // Restore sig int/quit | |
668 | signal(SIGQUIT,old_SIGQUIT); | |
669 | signal(SIGINT,old_SIGINT); | |
670 | return _error->Errno("waitpid","Couldn't wait for subprocess"); | |
671 | } | |
d8cb4aa4 MV |
672 | |
673 | // wait for input or output here | |
955a6ddb MV |
674 | FD_ZERO(&rfds); |
675 | FD_SET(0, &rfds); | |
676 | FD_SET(_dpkgin, &rfds); | |
677 | FD_SET(master, &rfds); | |
090c6566 MV |
678 | tv.tv_sec = 1; |
679 | tv.tv_usec = 0; | |
7fdafa0f | 680 | select_ret = select(max(master, _dpkgin)+1, &rfds, NULL, NULL, &tv); |
090c6566 MV |
681 | if (select_ret < 0) |
682 | std::cerr << "Error in select()" << std::endl; | |
683 | else if (select_ret == 0) | |
03e39e59 | 684 | continue; |
d8cb4aa4 | 685 | |
955a6ddb MV |
686 | if(FD_ISSET(master, &rfds)) |
687 | DoTerminalPty(master, term_out); | |
688 | if(FD_ISSET(0, &rfds)) | |
689 | DoStdin(master); | |
75ef8f14 | 690 | |
97efd303 | 691 | // FIXME: move this into its own function too |
76d94037 MV |
692 | // FIXME2: do not use non-blocking read here, |
693 | // read/process as much data as possible | |
694 | // Yin one run | |
97efd303 | 695 | //DoDpkgStatusFd(); |
955a6ddb | 696 | if(FD_ISSET(_dpkgin, &rfds)) |
7fdafa0f | 697 | while(true) |
75ef8f14 | 698 | { |
7fdafa0f MV |
699 | if(read(_dpkgin, buf, 1) <= 0) |
700 | break; | |
75ef8f14 | 701 | |
7fdafa0f MV |
702 | // sanity check (should never happen) |
703 | if(strlen(line) >= sizeof(line)-10) | |
704 | { | |
705 | _error->Error("got a overlong line from dpkg: '%s'",line); | |
706 | line[0]=0; | |
707 | continue; | |
708 | } | |
709 | // append to line, check if we got a complete line | |
710 | strcat(line, buf); | |
711 | if(buf[0] != '\n') | |
712 | continue; | |
75ef8f14 | 713 | |
7fdafa0f MV |
714 | if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true) |
715 | std::clog << "got from dpkg '" << line << "'" << std::endl; | |
75ef8f14 | 716 | |
7fdafa0f MV |
717 | // the status we output |
718 | ostringstream status; | |
75ef8f14 | 719 | |
7fdafa0f MV |
720 | /* dpkg sends strings like this: |
721 | 'status: <pkg>: <pkg qstate>' | |
722 | errors look like this: | |
723 | '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 | |
724 | and conffile-prompt like this | |
725 | 'status: conffile-prompt: conffile : 'current-conffile' 'new-conffile' useredited distedited | |
75ef8f14 | 726 | |
7fdafa0f MV |
727 | */ |
728 | char* list[5]; | |
729 | // dpkg sends multiline error messages sometimes (see | |
730 | // #374195 for a example. we should support this by | |
731 | // either patching dpkg to not send multiline over the | |
732 | // statusfd or by rewriting the code here to deal with | |
733 | // it. for now we just ignore it and not crash | |
734 | TokSplitString(':', line, list, sizeof(list)/sizeof(list[0])); | |
735 | char *pkg = list[1]; | |
736 | char *action = _strstrip(list[2]); | |
737 | if( pkg == NULL || action == NULL) | |
738 | { | |
739 | if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true) | |
740 | std::clog << "ignoring line: not enough ':'" << std::endl; | |
741 | // reset the line buffer | |
742 | line[0]=0; | |
743 | continue; | |
744 | } | |
75ef8f14 | 745 | |
7fdafa0f MV |
746 | if(strncmp(action,"error",strlen("error")) == 0) |
747 | { | |
748 | status << "pmerror:" << list[1] | |
749 | << ":" << (Done/float(Total)*100.0) | |
750 | << ":" << list[3] | |
751 | << endl; | |
752 | if(OutStatusFd > 0) | |
753 | write(OutStatusFd, status.str().c_str(), status.str().size()); | |
754 | line[0]=0; | |
755 | if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true) | |
756 | std::clog << "send: '" << status.str() << "'" << endl; | |
757 | continue; | |
758 | } | |
759 | if(strncmp(action,"conffile",strlen("conffile")) == 0) | |
760 | { | |
761 | status << "pmconffile:" << list[1] | |
762 | << ":" << (Done/float(Total)*100.0) | |
763 | << ":" << list[3] | |
764 | << endl; | |
765 | if(OutStatusFd > 0) | |
766 | write(OutStatusFd, status.str().c_str(), status.str().size()); | |
767 | line[0]=0; | |
768 | if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true) | |
769 | std::clog << "send: '" << status.str() << "'" << endl; | |
770 | continue; | |
771 | } | |
75ef8f14 | 772 | |
7fdafa0f MV |
773 | vector<struct DpkgState> &states = PackageOps[pkg]; |
774 | const char *next_action = NULL; | |
775 | if(PackageOpsDone[pkg] < states.size()) | |
776 | next_action = states[PackageOpsDone[pkg]].state; | |
777 | // check if the package moved to the next dpkg state | |
778 | if(next_action && (strcmp(action, next_action) == 0)) | |
779 | { | |
780 | // only read the translation if there is actually a next | |
781 | // action | |
782 | const char *translation = _(states[PackageOpsDone[pkg]].str); | |
783 | char s[200]; | |
784 | snprintf(s, sizeof(s), translation, pkg); | |
785 | ||
786 | // we moved from one dpkg state to a new one, report that | |
787 | PackageOpsDone[pkg]++; | |
788 | Done++; | |
789 | // build the status str | |
790 | status << "pmstatus:" << pkg | |
791 | << ":" << (Done/float(Total)*100.0) | |
792 | << ":" << s | |
793 | << endl; | |
794 | if(OutStatusFd > 0) | |
795 | write(OutStatusFd, status.str().c_str(), status.str().size()); | |
796 | if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true) | |
797 | std::clog << "send: '" << status.str() << "'" << endl; | |
75ef8f14 | 798 | |
7fdafa0f MV |
799 | } |
800 | if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true) | |
801 | std::clog << "(parsed from dpkg) pkg: " << pkg | |
802 | << " action: " << action << endl; | |
7f9a6360 | 803 | |
7fdafa0f MV |
804 | // reset the line buffer |
805 | line[0]=0; | |
806 | } | |
03e39e59 | 807 | } |
75ef8f14 | 808 | close(_dpkgin); |
d8cb4aa4 | 809 | fclose(term_out); |
03e39e59 AL |
810 | |
811 | // Restore sig int/quit | |
7f9a6360 AL |
812 | signal(SIGQUIT,old_SIGQUIT); |
813 | signal(SIGINT,old_SIGINT); | |
d8cb4aa4 MV |
814 | |
815 | tcsetattr(0, TCSAFLUSH, &tt); | |
6dd55be7 AL |
816 | |
817 | // Check for an error code. | |
818 | if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0) | |
819 | { | |
c70496f9 MV |
820 | // if it was set to "keep-dpkg-runing" then we won't return |
821 | // here but keep the loop going and just report it as a error | |
822 | // for later | |
823 | bool stopOnError = _config->FindB("Dpkg::StopOnError",true); | |
f956efb4 | 824 | |
c70496f9 MV |
825 | if(stopOnError) |
826 | RunScripts("DPkg::Post-Invoke"); | |
827 | ||
828 | if (WIFSIGNALED(Status) != 0 && WTERMSIG(Status) == SIGSEGV) | |
829 | _error->Error("Sub-process %s received a segmentation fault.",Args[0]); | |
830 | else if (WIFEXITED(Status) != 0) | |
831 | _error->Error("Sub-process %s returned an error code (%u)",Args[0],WEXITSTATUS(Status)); | |
832 | else | |
833 | _error->Error("Sub-process %s exited unexpectedly",Args[0]); | |
834 | ||
835 | if(stopOnError) | |
836 | return false; | |
6dd55be7 | 837 | } |
03e39e59 | 838 | } |
6dd55be7 AL |
839 | |
840 | if (RunScripts("DPkg::Post-Invoke") == false) | |
841 | return false; | |
03e39e59 AL |
842 | return true; |
843 | } | |
844 | /*}}}*/ | |
281daf46 AL |
845 | // pkgDpkgPM::Reset - Dump the contents of the command list /*{{{*/ |
846 | // --------------------------------------------------------------------- | |
847 | /* */ | |
848 | void pkgDPkgPM::Reset() | |
849 | { | |
850 | List.erase(List.begin(),List.end()); | |
851 | } | |
852 | /*}}}*/ |