apt-pkg/edsp.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 /* ######################################################################
   4    Set of methods to help writing and reading everything needed for EDSP
   5    ##################################################################### */
   6                                                                         /*}}}*/
   7 // Include Files                                                        /*{{{*/
   8 #include <apt-pkg/edsp.h>
   9 #include <apt-pkg/error.h>
  10 #include <apt-pkg/configuration.h>
  11 #include <apt-pkg/version.h>
  12 #include <apt-pkg/policy.h>
  13 #include <apt-pkg/tagfile.h>
  14
  15 #include <apti18n.h>
  16 #include <limits>
  17
  18 #include <stdio.h>
  19                                                                         /*}}}*/
  20
  21 // we could use pkgCache::DepType and ::Priority, but these would be localized strings…
  22 const char * const EDSP::PrioMap[] = {0, "important", "required", "standard",
  23                                       "optional", "extra"};
  24 const char * const EDSP::DepMap[] = {"", "Depends", "PreDepends", "Suggests",
  25                                      "Recommends" , "Conflicts", "Replaces",
  26                                      "Obsoletes", "Breaks", "Enhances"};
  27
  28 // EDSP::WriteScenario - to the given file descriptor                   /*{{{*/
  29 bool EDSP::WriteScenario(pkgDepCache &Cache, FILE* output)
  30 {
  31    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
  32       for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
  33       {
  34          WriteScenarioVersion(Cache, output, Pkg, Ver);
  35          WriteScenarioDependency(Cache, output, Pkg, Ver);
  36          fprintf(output, "\n");
  37       }
  38    return true;
  39 }
  40                                                                         /*}}}*/
  41 // EDSP::WriteLimitedScenario - to the given file descriptor            /*{{{*/
  42 bool EDSP::WriteLimitedScenario(pkgDepCache &Cache, FILE* output,
  43                                 APT::PackageSet const &pkgset)
  44 {
  45    for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
  46       for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
  47       {
  48          WriteScenarioVersion(Cache, output, Pkg, Ver);
  49          WriteScenarioLimitedDependency(Cache, output, Pkg, Ver, pkgset);
  50          fprintf(output, "\n");
  51       }
  52    return true;
  53 }
  54                                                                         /*}}}*/
  55 // EDSP::WriteScenarioVersion                                           /*{{{*/
  56 void EDSP::WriteScenarioVersion(pkgDepCache &Cache, FILE* output, pkgCache::PkgIterator const &Pkg,
  57                                 pkgCache::VerIterator const &Ver)
  58 {
  59    fprintf(output, "Package: %s\n", Pkg.Name());
  60    fprintf(output, "Architecture: %s\n", Ver.Arch());
  61    fprintf(output, "Version: %s\n", Ver.VerStr());
  62    if (Pkg.CurrentVer() == Ver)
  63       fprintf(output, "Installed: yes\n");
  64    if (Pkg->SelectedState == pkgCache::State::Hold)
  65       fprintf(output, "Hold: yes\n");
  66    fprintf(output, "APT-ID: %d\n", Ver->ID);
  67    fprintf(output, "Priority: %s\n", PrioMap[Ver->Priority]);
  68    if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
  69       fprintf(output, "Essential: yes\n");
  70    fprintf(output, "Section: %s\n", Ver.Section());
  71    if (Ver->MultiArch == pkgCache::Version::Allowed || Ver->MultiArch == pkgCache::Version::AllAllowed)
  72       fprintf(output, "Multi-Arch: allowed\n");
  73    else if (Ver->MultiArch == pkgCache::Version::Foreign || Ver->MultiArch == pkgCache::Version::AllForeign)
  74       fprintf(output, "Multi-Arch: foreign\n");
  75    else if (Ver->MultiArch == pkgCache::Version::Same)
  76       fprintf(output, "Multi-Arch: same\n");
  77    signed short Pin = std::numeric_limits<signed short>::min();
  78    for (pkgCache::VerFileIterator File = Ver.FileList(); File.end() == false; ++File) {
  79       signed short const p = Cache.GetPolicy().GetPriority(File.File());
  80       if (Pin < p)
  81          Pin = p;
  82    }
  83    fprintf(output, "APT-Pin: %d\n", Pin);
  84    if (Cache.GetCandidateVer(Pkg) == Ver)
  85       fprintf(output, "APT-Candidate: yes\n");
  86    if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
  87       fprintf(output, "APT-Automatic: yes\n");
  88 }
  89                                                                         /*}}}*/
  90 // EDSP::WriteScenarioDependency                                        /*{{{*/
  91 void EDSP::WriteScenarioDependency(pkgDepCache &Cache, FILE* output, pkgCache::PkgIterator const &Pkg,
  92                                 pkgCache::VerIterator const &Ver)
  93 {
  94    std::string dependencies[pkgCache::Dep::Enhances + 1];
  95    bool orGroup = false;
  96    for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
  97    {
  98       // Ignore implicit dependencies for multiarch here
  99       if (strcmp(Pkg.Arch(), Dep.TargetPkg().Arch()) != 0)
 100          continue;
 101       if (orGroup == false)
 102          dependencies[Dep->Type].append(", ");
 103       dependencies[Dep->Type].append(Dep.TargetPkg().Name());
 104       if (Dep->Version != 0)
 105          dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")");
 106       if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
 107       {
 108          dependencies[Dep->Type].append(" | ");
 109          orGroup = true;
 110       }
 111       else
 112          orGroup = false;
 113    }
 114    for (int i = 1; i < pkgCache::Dep::Enhances + 1; ++i)
 115       if (dependencies[i].empty() == false)
 116          fprintf(output, "%s: %s\n", DepMap[i], dependencies[i].c_str()+2);
 117    string provides;
 118    for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
 119    {
 120       // Ignore implicit provides for multiarch here
 121       if (strcmp(Pkg.Arch(), Prv.ParentPkg().Arch()) != 0 || strcmp(Pkg.Name(),Prv.Name()) == 0)
 122          continue;
 123       provides.append(", ").append(Prv.Name());
 124    }
 125    if (provides.empty() == false)
 126       fprintf(output, "Provides: %s\n", provides.c_str()+2);
 127 }
 128                                                                         /*}}}*/
 129 // EDSP::WriteScenarioLimitedDependency                                 /*{{{*/
 130 void EDSP::WriteScenarioLimitedDependency(pkgDepCache &Cache, FILE* output,
 131                                           pkgCache::PkgIterator const &Pkg,
 132                                           pkgCache::VerIterator const &Ver,
 133                                           APT::PackageSet const &pkgset)
 134 {
 135    std::string dependencies[pkgCache::Dep::Enhances + 1];
 136    bool orGroup = false;
 137    for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
 138    {
 139       // Ignore implicit dependencies for multiarch here
 140       if (strcmp(Pkg.Arch(), Dep.TargetPkg().Arch()) != 0)
 141          continue;
 142       if (orGroup == false)
 143       {
 144          if (pkgset.find(Dep.TargetPkg()) == pkgset.end())
 145             continue;
 146          dependencies[Dep->Type].append(", ");
 147       }
 148       else if (pkgset.find(Dep.TargetPkg()) == pkgset.end())
 149       {
 150          if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
 151             continue;
 152          dependencies[Dep->Type].erase(dependencies[Dep->Type].end()-3, dependencies[Dep->Type].end());
 153          orGroup = false;
 154          continue;
 155       }
 156       dependencies[Dep->Type].append(Dep.TargetPkg().Name());
 157       if (Dep->Version != 0)
 158          dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")");
 159       if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
 160       {
 161          dependencies[Dep->Type].append(" | ");
 162          orGroup = true;
 163       }
 164       else
 165          orGroup = false;
 166    }
 167    for (int i = 1; i < pkgCache::Dep::Enhances + 1; ++i)
 168       if (dependencies[i].empty() == false)
 169          fprintf(output, "%s: %s\n", DepMap[i], dependencies[i].c_str()+2);
 170    string provides;
 171    for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
 172    {
 173       // Ignore implicit provides for multiarch here
 174       if (strcmp(Pkg.Arch(), Prv.ParentPkg().Arch()) != 0 || strcmp(Pkg.Name(),Prv.Name()) == 0)
 175          continue;
 176       if (pkgset.find(Prv.ParentPkg()) == pkgset.end())
 177          continue;
 178       provides.append(", ").append(Prv.Name());
 179    }
 180    if (provides.empty() == false)
 181       fprintf(output, "Provides: %s\n", provides.c_str()+2);
 182 }
 183                                                                         /*}}}*/
 184 // EDSP::WriteRequest - to the given file descriptor                    /*{{{*/
 185 bool EDSP::WriteRequest(pkgDepCache &Cache, FILE* output, bool const Upgrade,
 186                         bool const DistUpgrade, bool const AutoRemove)
 187 {
 188    string del, inst;
 189    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
 190    {
 191       string* req;
 192       if (Cache[Pkg].Delete() == true)
 193          req = &del;
 194       else if (Cache[Pkg].NewInstall() == true || Cache[Pkg].Upgrade() == true)
 195          req = &inst;
 196       else
 197          continue;
 198       req->append(" ").append(Pkg.FullName());
 199    }
 200    fprintf(output, "Request: EDSP 0.2\n");
 201    if (del.empty() == false)
 202       fprintf(output, "Remove: %s\n", del.c_str()+1);
 203    if (inst.empty() == false)
 204       fprintf(output, "Install: %s\n", inst.c_str()+1);
 205    if (Upgrade == true)
 206       fprintf(output, "Upgrade: yes\n");
 207    if (DistUpgrade == true)
 208       fprintf(output, "Dist-Upgrade: yes\n");
 209    if (AutoRemove == true)
 210       fprintf(output, "Autoremove: yes\n");
 211    if (_config->FindB("APT::Solver::Strict-Pinning", true) == false)
 212       fprintf(output, "Strict-Pinning: no\n");
 213    string solverpref("APT::Solver::");
 214    solverpref.append(_config->Find("APT::Solver::Name", "internal")).append("::Preferences");
 215    if (_config->Exists(solverpref) == true)
 216       fprintf(output, "Preferences: %s\n", _config->Find(solverpref,"").c_str());
 217    fprintf(output, "\n");
 218
 219    return true;
 220 }
 221                                                                         /*}}}*/
 222 // EDSP::ReadResponse - from the given file descriptor                  /*{{{*/
 223 bool EDSP::ReadResponse(int const input, pkgDepCache &Cache) {
 224         /* We build an map id to mmap offset here
 225            In theory we could use the offset as ID, but then VersionCount
 226            couldn't be used to create other versionmappings anymore and it
 227            would be too easy for a (buggy) solver to segfault APT… */
 228         unsigned long long const VersionCount = Cache.Head().VersionCount;
 229         unsigned long VerIdx[VersionCount];
 230         for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; ++P)
 231                 for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; ++V)
 232                         VerIdx[V->ID] = V.Index();
 233
 234         FileFd in;
 235         in.OpenDescriptor(input, FileFd::ReadOnly);
 236         pkgTagFile response(&in, 100);
 237         pkgTagSection section;
 238
 239         while (response.Step(section) == true) {
 240                 std::string type;
 241                 if (section.Exists("Install") == true)
 242                         type = "Install";
 243                 else if (section.Exists("Remove") == true)
 244                         type = "Remove";
 245                 else if (section.Exists("Progress") == true) {
 246                         std::clog << TimeRFC1123(time(NULL)) << " ";
 247                         ioprintf(std::clog, "[ %3d%% ] ", section.FindI("Percentage", 0));
 248                         std::clog << section.FindS("Progress") << " - ";
 249                         string const msg = section.FindS("Message");
 250                         if (msg.empty() == true)
 251                                 std::clog << "Solver is still working on the solution" << std::endl;
 252                         else
 253                                 std::clog << msg << std::endl;
 254                         continue;
 255                 } else
 256                         continue;
 257
 258                 size_t const id = section.FindULL(type.c_str(), VersionCount);
 259                 if (id == VersionCount) {
 260                         _error->Warning("Unable to parse %s request with id value '%s'!", type.c_str(), section.FindS(type.c_str()).c_str());
 261                         continue;
 262                 } else if (id > Cache.Head().VersionCount) {
 263                         _error->Warning("ID value '%s' in %s request stanza is to high to refer to a known version!", section.FindS(type.c_str()).c_str(), type.c_str());
 264                         continue;
 265                 }
 266
 267                 pkgCache::VerIterator Ver(Cache.GetCache(), Cache.GetCache().VerP + VerIdx[id]);
 268                 Cache.SetCandidateVersion(Ver);
 269                 if (type == "Install")
 270                         Cache.MarkInstall(Ver.ParentPkg(), false, false);
 271                 else if (type == "Remove")
 272                         Cache.MarkDelete(Ver.ParentPkg(), false);
 273         }
 274         return true;
 275 }
 276                                                                         /*}}}*/
 277 // EDSP::ReadLine - first line from the given file descriptor           /*{{{*/
 278 // ---------------------------------------------------------------------
 279 /* Little helper method to read a complete line into a string. Similar to
 280    fgets but we need to use the low-level read() here as otherwise the
 281    listparser will be confused later on as mixing of fgets and read isn't
 282    a supported action according to the manpages and results are undefined */
 283 bool EDSP::ReadLine(int const input, std::string &line) {
 284         char one;
 285         ssize_t data = 0;
 286         line.erase();
 287         line.reserve(100);
 288         while ((data = read(input, &one, sizeof(one))) != -1) {
 289                 if (data != 1)
 290                         continue;
 291                 if (one == '\n')
 292                         return true;
 293                 if (one == '\r')
 294                         continue;
 295                 if (line.empty() == true && isblank(one) != 0)
 296                         continue;
 297                 line += one;
 298         }
 299         return false;
 300 }
 301                                                                         /*}}}*/
 302 // EDSP::StringToBool - convert yes/no to bool                          /*{{{*/
 303 // ---------------------------------------------------------------------
 304 /* we are not as lazy as we are in the global StringToBool as we really
 305    only accept yes/no here - but we will ignore leading spaces */
 306 bool EDSP::StringToBool(char const *answer, bool const defValue) {
 307    for (; isspace(*answer) != 0; ++answer);
 308    if (strncasecmp(answer, "yes", 3) == 0)
 309       return true;
 310    else if (strncasecmp(answer, "no", 2) == 0)
 311       return false;
 312    else
 313       _error->Warning("Value '%s' is not a boolean 'yes' or 'no'!", answer);
 314    return defValue;
 315 }
 316                                                                         /*}}}*/
 317 // EDSP::ReadRequest - first stanza from the given file descriptor      /*{{{*/
 318 bool EDSP::ReadRequest(int const input, std::list<std::string> &install,
 319                         std::list<std::string> &remove, bool &upgrade,
 320                         bool &distUpgrade, bool &autoRemove)
 321 {
 322    install.clear();
 323    remove.clear();
 324    upgrade = false;
 325    distUpgrade = false;
 326    autoRemove = false;
 327    std::string line;
 328    while (ReadLine(input, line) == true)
 329    {
 330       // Skip empty lines before request
 331       if (line.empty() == true)
 332          continue;
 333       // The first Tag must be a request, so search for it
 334       if (line.compare(0, 8, "Request:") != 0)
 335          continue;
 336
 337       while (ReadLine(input, line) == true)
 338       {
 339          // empty lines are the end of the request
 340          if (line.empty() == true)
 341             return true;
 342
 343          std::list<std::string> *request = NULL;
 344          if (line.compare(0, 8, "Install:") == 0)
 345          {
 346             line.erase(0, 8);
 347             request = &install;
 348          }
 349          else if (line.compare(0, 7, "Remove:") == 0)
 350          {
 351             line.erase(0, 7);
 352             request = &remove;
 353          }
 354          else if (line.compare(0, 8, "Upgrade:") == 0)
 355             upgrade = EDSP::StringToBool(line.c_str() + 9, false);
 356          else if (line.compare(0, 13, "Dist-Upgrade:") == 0)
 357             distUpgrade = EDSP::StringToBool(line.c_str() + 14, false);
 358          else if (line.compare(0, 11, "Autoremove:") == 0)
 359             autoRemove = EDSP::StringToBool(line.c_str() + 12, false);
 360          else
 361             _error->Warning("Unknown line in EDSP Request stanza: %s", line.c_str());
 362
 363          if (request == NULL)
 364             continue;
 365          size_t end = line.length();
 366          do {
 367             size_t begin = line.rfind(' ');
 368             if (begin == std::string::npos)
 369             {
 370                request->push_back(line.substr(0, end));
 371                break;
 372             }
 373             else if (begin < end)
 374                request->push_back(line.substr(begin + 1, end));
 375             line.erase(begin);
 376             end = line.find_last_not_of(' ');
 377          } while (end != std::string::npos);
 378       }
 379    }
 380    return false;
 381 }
 382                                                                         /*}}}*/
 383 // EDSP::ApplyRequest - first stanza from the given file descriptor     /*{{{*/
 384 bool EDSP::ApplyRequest(std::list<std::string> const &install,
 385                          std::list<std::string> const &remove,
 386                          pkgDepCache &Cache)
 387 {
 388         for (std::list<std::string>::const_iterator i = install.begin();
 389              i != install.end(); ++i) {
 390                 pkgCache::PkgIterator P = Cache.FindPkg(*i);
 391                 if (P.end() == true)
 392                         _error->Warning("Package %s is not known, so can't be installed", i->c_str());
 393                 else
 394                         Cache.MarkInstall(P, false);
 395         }
 396
 397         for (std::list<std::string>::const_iterator i = remove.begin();
 398              i != remove.end(); ++i) {
 399                 pkgCache::PkgIterator P = Cache.FindPkg(*i);
 400                 if (P.end() == true)
 401                         _error->Warning("Package %s is not known, so can't be installed", i->c_str());
 402                 else
 403                         Cache.MarkDelete(P);
 404         }
 405         return true;
 406 }
 407                                                                         /*}}}*/
 408 // EDSP::WriteSolution - to the given file descriptor                   /*{{{*/
 409 bool EDSP::WriteSolution(pkgDepCache &Cache, FILE* output)
 410 {
 411    bool const Debug = _config->FindB("Debug::EDSP::WriteSolution", false);
 412    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
 413    {
 414       if (Cache[Pkg].Delete() == true)
 415       {
 416          fprintf(output, "Remove: %d\n", Pkg.CurrentVer()->ID);
 417          if (Debug == true)
 418             fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());
 419       }
 420       else if (Cache[Pkg].NewInstall() == true || Cache[Pkg].Upgrade() == true)
 421       {
 422          fprintf(output, "Install: %d\n", Cache.GetCandidateVer(Pkg)->ID);
 423          if (Debug == true)
 424             fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Cache.GetCandidateVer(Pkg).VerStr());
 425       }
 426       else
 427          continue;
 428       fprintf(output, "\n");
 429    }
 430
 431    return true;
 432 }
 433                                                                         /*}}}*/
 434 // EDSP::WriteProgess - pulse to the given file descriptor              /*{{{*/
 435 bool EDSP::WriteProgress(unsigned short const percent, const char* const message, FILE* output) {
 436         fprintf(output, "Progress: %s\n", TimeRFC1123(time(NULL)).c_str());
 437         fprintf(output, "Percentage: %d\n", percent);
 438         fprintf(output, "Message: %s\n\n", message);
 439         fflush(output);
 440         return true;
 441 }
 442                                                                         /*}}}*/
 443 bool EDSP::WriteError(std::string const &message, FILE* output) { return false; }