You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

1433 lines
42 KiB

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