apt-pkg/deb/debsystem.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: debsystem.cc,v 1.4 2004/01/26 17:01:53 mdz Exp $
   4 /* ######################################################################
   5
   6    System - Abstraction for running on different systems.
   7
   8    Basic general structure..
   9
  10    ##################################################################### */
  11                                                                         /*}}}*/
  12 // Include Files                                                        /*{{{*/
  13 #include <config.h>
  14
  15 #include <apt-pkg/debsystem.h>
  16 #include <apt-pkg/debversion.h>
  17 #include <apt-pkg/debindexfile.h>
  18 #include <apt-pkg/dpkgpm.h>
  19 #include <apt-pkg/configuration.h>
  20 #include <apt-pkg/error.h>
  21 #include <apt-pkg/fileutl.h>
  22 #include <apt-pkg/pkgcache.h>
  23 #include <apt-pkg/cacheiterators.h>
  24
  25 #include <algorithm>
  26
  27 #include <ctype.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <string>
  31 #include <vector>
  32 #include <unistd.h>
  33 #include <dirent.h>
  34 #include <errno.h>
  35 #include <sys/types.h>
  36 #include <sys/stat.h>
  37 #include <sys/wait.h>
  38 #include <fcntl.h>
  39
  40 #include <apti18n.h>
  41                                                                         /*}}}*/
  42
  43 using std::string;
  44
  45 debSystem debSys;
  46
  47 class APT_HIDDEN debSystemPrivate {
  48 public:
  49    debSystemPrivate() : LockFD(-1), LockCount(0), StatusFile(0)
  50    {
  51    }
  52    // For locking support
  53    int LockFD;
  54    unsigned LockCount;
  55
  56    debStatusIndex *StatusFile;
  57 };
  58
  59 // System::debSystem - Constructor                                      /*{{{*/
  60 // ---------------------------------------------------------------------
  61 /* */
  62 debSystem::debSystem() : pkgSystem("Debian dpkg interface", &debVS), d(new debSystemPrivate())
  63 {
  64 }
  65                                                                         /*}}}*/
  66 // System::~debSystem - Destructor                                      /*{{{*/
  67 // ---------------------------------------------------------------------
  68 /* */
  69 debSystem::~debSystem()
  70 {
  71    delete d->StatusFile;
  72    delete d;
  73 }
  74                                                                         /*}}}*/
  75 // System::Lock - Get the lock                                          /*{{{*/
  76 // ---------------------------------------------------------------------
  77 /* This mirrors the operations dpkg does when it starts up. Note the
  78    checking of the updates directory. */
  79 bool debSystem::Lock()
  80 {
  81    // Disable file locking
  82    if (_config->FindB("Debug::NoLocking",false) == true || d->LockCount > 1)
  83    {
  84       d->LockCount++;
  85       return true;
  86    }
  87
  88    // Create the lockfile
  89    string AdminDir = flNotFile(_config->Find("Dir::State::status"));
  90    d->LockFD = GetLock(AdminDir + "lock");
  91    if (d->LockFD == -1)
  92    {
  93       if (errno == EACCES || errno == EAGAIN)
  94          return _error->Error(_("Unable to lock the administration directory (%s), "
  95                                 "is another process using it?"),AdminDir.c_str());
  96       else
  97          return _error->Error(_("Unable to lock the administration directory (%s), "
  98                                 "are you root?"),AdminDir.c_str());
  99    }
 100
 101    // See if we need to abort with a dirty journal
 102    if (CheckUpdates() == true)
 103    {
 104       close(d->LockFD);
 105       d->LockFD = -1;
 106       const char *cmd;
 107       if (getenv("SUDO_USER") != NULL)
 108          cmd = "sudo dpkg --configure -a";
 109       else
 110          cmd = "dpkg --configure -a";
 111       // TRANSLATORS: the %s contains the recovery command, usually
 112       //              dpkg --configure -a
 113       return _error->Error(_("dpkg was interrupted, you must manually "
 114                              "run '%s' to correct the problem. "), cmd);
 115    }
 116
 117          d->LockCount++;
 118
 119    return true;
 120 }
 121                                                                         /*}}}*/
 122 // System::UnLock - Drop a lock                                         /*{{{*/
 123 // ---------------------------------------------------------------------
 124 /* */
 125 bool debSystem::UnLock(bool NoErrors)
 126 {
 127    if (d->LockCount == 0 && NoErrors == true)
 128       return false;
 129
 130    if (d->LockCount < 1)
 131       return _error->Error(_("Not locked"));
 132    if (--d->LockCount == 0)
 133    {
 134       close(d->LockFD);
 135       d->LockCount = 0;
 136    }
 137
 138    return true;
 139 }
 140                                                                         /*}}}*/
 141 // System::CheckUpdates - Check if the updates dir is dirty             /*{{{*/
 142 // ---------------------------------------------------------------------
 143 /* This does a check of the updates directory (dpkg journal) to see if it has
 144    any entries in it. */
 145 bool debSystem::CheckUpdates()
 146 {
 147    // Check for updates.. (dirty)
 148    string File = flNotFile(_config->Find("Dir::State::status")) + "updates/";
 149    DIR *DirP = opendir(File.c_str());
 150    if (DirP == 0)
 151       return false;
 152
 153    /* We ignore any files that are not all digits, this skips .,.. and
 154       some tmp files dpkg will leave behind.. */
 155    bool Damaged = false;
 156    for (struct dirent *Ent = readdir(DirP); Ent != 0; Ent = readdir(DirP))
 157    {
 158       Damaged = true;
 159       for (unsigned int I = 0; Ent->d_name[I] != 0; I++)
 160       {
 161          // Check if its not a digit..
 162          if (isdigit(Ent->d_name[I]) == 0)
 163          {
 164             Damaged = false;
 165             break;
 166          }
 167       }
 168       if (Damaged == true)
 169          break;
 170    }
 171    closedir(DirP);
 172
 173    return Damaged;
 174 }
 175                                                                         /*}}}*/
 176 // System::CreatePM - Create the underlying package manager             /*{{{*/
 177 // ---------------------------------------------------------------------
 178 /* */
 179 pkgPackageManager *debSystem::CreatePM(pkgDepCache *Cache) const
 180 {
 181    return new pkgDPkgPM(Cache);
 182 }
 183                                                                         /*}}}*/
 184 // System::Initialize - Setup the configuration space..                 /*{{{*/
 185 // ---------------------------------------------------------------------
 186 /* These are the Debian specific configuration variables.. */
 187 bool debSystem::Initialize(Configuration &Cnf)
 188 {
 189    /* These really should be jammed into a generic 'Local Database' engine
 190       which is yet to be determined. The functions in pkgcachegen should
 191       be the only users of these */
 192    Cnf.CndSet("Dir::State::extended_states", "extended_states");
 193    Cnf.CndSet("Dir::State::status","/var/lib/dpkg/status");
 194    Cnf.CndSet("Dir::Bin::dpkg","/usr/bin/dpkg");
 195
 196    if (d->StatusFile) {
 197      delete d->StatusFile;
 198      d->StatusFile = 0;
 199    }
 200
 201    return true;
 202 }
 203                                                                         /*}}}*/
 204 // System::ArchiveSupported - Is a file format supported                /*{{{*/
 205 // ---------------------------------------------------------------------
 206 /* The standard name for a deb is 'deb'.. There are no separate versions
 207    of .deb to worry about.. */
 208 APT_PURE bool debSystem::ArchiveSupported(const char *Type)
 209 {
 210    if (strcmp(Type,"deb") == 0)
 211       return true;
 212    return false;
 213 }
 214                                                                         /*}}}*/
 215 // System::Score - Determine how 'Debiany' this sys is..                /*{{{*/
 216 // ---------------------------------------------------------------------
 217 /* We check some files that are sure tell signs of this being a Debian
 218    System.. */
 219 signed debSystem::Score(Configuration const &Cnf)
 220 {
 221    signed Score = 0;
 222    if (FileExists(Cnf.FindFile("Dir::State::status","/var/lib/dpkg/status")) == true)
 223        Score += 10;
 224    if (FileExists(Cnf.FindFile("Dir::Bin::dpkg","/usr/bin/dpkg")) == true)
 225       Score += 10;
 226    if (FileExists("/etc/debian_version") == true)
 227       Score += 10;
 228    return Score;
 229 }
 230                                                                         /*}}}*/
 231 // System::AddStatusFiles - Register the status files                   /*{{{*/
 232 // ---------------------------------------------------------------------
 233 /* */
 234 bool debSystem::AddStatusFiles(std::vector<pkgIndexFile *> &List)
 235 {
 236    if (d->StatusFile == 0)
 237       d->StatusFile = new debStatusIndex(_config->FindFile("Dir::State::status"));
 238    List.push_back(d->StatusFile);
 239    return true;
 240 }
 241                                                                         /*}}}*/
 242 // System::FindIndex - Get an index file for status files               /*{{{*/
 243 // ---------------------------------------------------------------------
 244 /* */
 245 bool debSystem::FindIndex(pkgCache::PkgFileIterator File,
 246                           pkgIndexFile *&Found) const
 247 {
 248    if (d->StatusFile == 0)
 249       return false;
 250    if (d->StatusFile->FindInCache(*File.Cache()) == File)
 251    {
 252       Found = d->StatusFile;
 253       return true;
 254    }
 255
 256    return false;
 257 }
 258                                                                         /*}}}*/
 259
 260 std::string debSystem::GetDpkgExecutable()                              /*{{{*/
 261 {
 262    string Tmp = _config->Find("Dir::Bin::dpkg","dpkg");
 263    string const dpkgChrootDir = _config->FindDir("DPkg::Chroot-Directory", "/");
 264    size_t dpkgChrootLen = dpkgChrootDir.length();
 265    if (dpkgChrootDir != "/" && Tmp.find(dpkgChrootDir) == 0)
 266    {
 267       if (dpkgChrootDir[dpkgChrootLen - 1] == '/')
 268          --dpkgChrootLen;
 269       Tmp = Tmp.substr(dpkgChrootLen);
 270    }
 271    return Tmp;
 272 }
 273                                                                         /*}}}*/
 274 std::vector<std::string> debSystem::GetDpkgBaseCommand()                /*{{{*/
 275 {
 276    // Generate the base argument list for dpkg
 277    std::vector<std::string> Args = { GetDpkgExecutable() };
 278    // Stick in any custom dpkg options
 279    Configuration::Item const *Opts = _config->Tree("DPkg::Options");
 280    if (Opts != 0)
 281    {
 282       Opts = Opts->Child;
 283       for (; Opts != 0; Opts = Opts->Next)
 284       {
 285          if (Opts->Value.empty() == true)
 286             continue;
 287          Args.push_back(Opts->Value);
 288       }
 289    }
 290    return Args;
 291 }
 292                                                                         /*}}}*/
 293 void debSystem::DpkgChrootDirectory()                                   /*{{{*/
 294 {
 295    std::string const chrootDir = _config->FindDir("DPkg::Chroot-Directory");
 296    if (chrootDir == "/")
 297       return;
 298    std::cerr << "Chrooting into " << chrootDir << std::endl;
 299    if (chroot(chrootDir.c_str()) != 0)
 300       _exit(100);
 301    if (chdir("/") != 0)
 302       _exit(100);
 303 }
 304                                                                         /*}}}*/
 305 pid_t debSystem::ExecDpkg(std::vector<std::string> const &sArgs, int * const inputFd, int * const outputFd, bool const DiscardOutput)/*{{{*/
 306 {
 307    std::vector<const char *> Args(sArgs.size(), NULL);
 308    std::transform(sArgs.begin(), sArgs.end(), Args.begin(), [](std::string const &s) { return s.c_str(); });
 309    Args.push_back(NULL);
 310
 311    int external[2] = {-1, -1};
 312    if (inputFd != nullptr || outputFd != nullptr)
 313       if (pipe(external) != 0)
 314       {
 315          _error->WarningE("dpkg", "Can't create IPC pipe for dpkg call");
 316          return -1;
 317       }
 318
 319    pid_t const dpkg = ExecFork();
 320    if (dpkg == 0) {
 321       int const nullfd = open("/dev/null", O_RDONLY);
 322       if (inputFd == nullptr)
 323          dup2(nullfd, STDIN_FILENO);
 324       else
 325       {
 326          close(external[1]);
 327          dup2(external[0], STDIN_FILENO);
 328       }
 329       if (outputFd == nullptr)
 330          dup2(nullfd, STDOUT_FILENO);
 331       else
 332       {
 333          close(external[0]);
 334          dup2(external[1], STDOUT_FILENO);
 335       }
 336       if (DiscardOutput == true)
 337          dup2(nullfd, STDERR_FILENO);
 338       debSystem::DpkgChrootDirectory();
 339       execvp(Args[0], (char**) &Args[0]);
 340       _error->WarningE("dpkg", "Can't execute dpkg!");
 341       _exit(100);
 342    }
 343    if (outputFd != nullptr)
 344    {
 345       close(external[1]);
 346       *outputFd = external[0];
 347    }
 348    else if (inputFd != nullptr)
 349    {
 350       close(external[0]);
 351       *inputFd = external[1];
 352    }
 353    return dpkg;
 354 }
 355                                                                         /*}}}*/
 356 bool debSystem::SupportsMultiArch()                                     /*{{{*/
 357 {
 358    std::vector<std::string> Args = GetDpkgBaseCommand();
 359    Args.push_back("--assert-multi-arch");
 360    pid_t const dpkgAssertMultiArch = ExecDpkg(Args, nullptr, nullptr, true);
 361    if (dpkgAssertMultiArch > 0)
 362    {
 363       int Status = 0;
 364       while (waitpid(dpkgAssertMultiArch, &Status, 0) != dpkgAssertMultiArch)
 365       {
 366          if (errno == EINTR)
 367             continue;
 368          _error->WarningE("dpkgGo", _("Waited for %s but it wasn't there"), "dpkg --assert-multi-arch");
 369          break;
 370       }
 371       if (WIFEXITED(Status) == true && WEXITSTATUS(Status) == 0)
 372          return true;
 373    }
 374    return false;
 375 }
 376                                                                         /*}}}*/
 377 std::vector<std::string> debSystem::SupportedArchitectures()            /*{{{*/
 378 {
 379    std::vector<std::string> archs;
 380    {
 381       string const arch = _config->Find("APT::Architecture");
 382       if (arch.empty() == false)
 383          archs.push_back(std::move(arch));
 384    }
 385
 386    std::vector<std::string> sArgs = GetDpkgBaseCommand();
 387    sArgs.push_back("--print-foreign-architectures");
 388    int outputFd = -1;
 389    pid_t const dpkgMultiArch = ExecDpkg(sArgs, nullptr, &outputFd, true);
 390    if (dpkgMultiArch == -1)
 391       return archs;
 392
 393    FILE *dpkg = fdopen(outputFd, "r");
 394    if(dpkg != NULL) {
 395       char* buf = NULL;
 396       size_t bufsize = 0;
 397       while (getline(&buf, &bufsize, dpkg) != -1)
 398       {
 399          char* tok_saveptr;
 400          char* arch = strtok_r(buf, " ", &tok_saveptr);
 401          while (arch != NULL) {
 402             for (; isspace(*arch) != 0; ++arch);
 403             if (arch[0] != '\0') {
 404                char const* archend = arch;
 405                for (; isspace(*archend) == 0 && *archend != '\0'; ++archend);
 406                string a(arch, (archend - arch));
 407                if (std::find(archs.begin(), archs.end(), a) == archs.end())
 408                   archs.push_back(a);
 409             }
 410             arch = strtok_r(NULL, " ", &tok_saveptr);
 411          }
 412       }
 413       free(buf);
 414       fclose(dpkg);
 415    }
 416    ExecWait(dpkgMultiArch, "dpkg --print-foreign-architectures", true);
 417    return archs;
 418 }
 419                                                                         /*}}}*/