apt-pkg/deb/debindexfile.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: debindexfile.cc,v 1.5.2.3 2004/01/04 19:11:00 mdz Exp $
   4 /* ######################################################################
   5
   6    Debian Specific sources.list types and the three sorts of Debian
   7    index files.
   8
   9    ##################################################################### */
  10                                                                         /*}}}*/
  11 // Include Files                                                        /*{{{*/
  12 #include <config.h>
  13
  14 #include <apt-pkg/debindexfile.h>
  15 #include <apt-pkg/debsrcrecords.h>
  16 #include <apt-pkg/deblistparser.h>
  17 #include <apt-pkg/debrecords.h>
  18 #include <apt-pkg/configuration.h>
  19 #include <apt-pkg/error.h>
  20 #include <apt-pkg/fileutl.h>
  21 #include <apt-pkg/indexfile.h>
  22 #include <apt-pkg/pkgcache.h>
  23 #include <apt-pkg/cacheiterators.h>
  24 #include <apt-pkg/pkgrecords.h>
  25 #include <apt-pkg/srcrecords.h>
  26
  27 #include <stdio.h>
  28 #include <iostream>
  29 #include <string>
  30 #include <sstream>
  31
  32 #include <sys/stat.h>
  33                                                                         /*}}}*/
  34
  35 // Sources Index                                                        /*{{{*/
  36 debSourcesIndex::debSourcesIndex(IndexTarget const &Target,bool const Trusted) :
  37      pkgDebianIndexTargetFile(Target, Trusted), d(NULL)
  38 {
  39 }
  40 std::string debSourcesIndex::SourceInfo(pkgSrcRecords::Parser const &Record,
  41                                    pkgSrcRecords::File const &File) const
  42 {
  43    // The result looks like: http://foo/debian/ stable/main src 1.1.1 (dsc)
  44    std::string Res = Target.Description;
  45    Res.erase(Target.Description.rfind(' '));
  46
  47    Res += " ";
  48    Res += Record.Package();
  49    Res += " ";
  50    Res += Record.Version();
  51    if (File.Type.empty() == false)
  52       Res += " (" + File.Type + ")";
  53    return Res;
  54 }
  55 pkgSrcRecords::Parser *debSourcesIndex::CreateSrcParser() const
  56 {
  57    std::string const SourcesURI = IndexFileName();
  58    if (FileExists(SourcesURI))
  59       return new debSrcRecordParser(SourcesURI, this);
  60    return NULL;
  61 }
  62 bool debSourcesIndex::OpenListFile(FileFd &, std::string const &)
  63 {
  64    return true;
  65 }
  66 pkgCacheListParser * debSourcesIndex::CreateListParser(FileFd &)
  67 {
  68    return NULL;
  69 }
  70 uint8_t debSourcesIndex::GetIndexFlags() const
  71 {
  72    return 0;
  73 }
  74                                                                         /*}}}*/
  75 // Packages Index                                                       /*{{{*/
  76 debPackagesIndex::debPackagesIndex(IndexTarget const &Target, bool const Trusted) :
  77                   pkgDebianIndexTargetFile(Target, Trusted), d(NULL)
  78 {
  79 }
  80 std::string debPackagesIndex::ArchiveInfo(pkgCache::VerIterator const &Ver) const
  81 {
  82    std::string Res = Target.Description;
  83    {
  84       auto const space = Target.Description.rfind(' ');
  85       if (space != std::string::npos)
  86          Res.erase(space);
  87    }
  88
  89    Res += " ";
  90    Res += Ver.ParentPkg().Name();
  91    Res += " ";
  92    std::string const Dist = Target.Option(IndexTarget::RELEASE);
  93    if (Dist.empty() == false && Dist[Dist.size() - 1] != '/')
  94       Res.append(Ver.Arch()).append(" ");
  95    Res += Ver.VerStr();
  96    return Res;
  97 }
  98 uint8_t debPackagesIndex::GetIndexFlags() const
  99 {
 100    return 0;
 101 }
 102                                                                         /*}}}*/
 103 // Translation-* Index                                                  /*{{{*/
 104 debTranslationsIndex::debTranslationsIndex(IndexTarget const &Target) :
 105                         pkgDebianIndexTargetFile(Target, true), d(NULL)
 106 {}
 107 bool debTranslationsIndex::HasPackages() const
 108 {
 109    return Exists();
 110 }
 111 bool debTranslationsIndex::OpenListFile(FileFd &Pkg, std::string const &FileName)
 112 {
 113    if (FileExists(FileName))
 114       return pkgDebianIndexTargetFile::OpenListFile(Pkg, FileName);
 115    return true;
 116 }
 117 uint8_t debTranslationsIndex::GetIndexFlags() const
 118 {
 119    return pkgCache::Flag::NotSource | pkgCache::Flag::NoPackages;
 120 }
 121 std::string debTranslationsIndex::GetArchitecture() const
 122 {
 123    return std::string();
 124 }
 125 pkgCacheListParser * debTranslationsIndex::CreateListParser(FileFd &Pkg)
 126 {
 127    if (Pkg.IsOpen() == false)
 128       return nullptr;
 129    _error->PushToStack();
 130    pkgCacheListParser * const Parser = new debTranslationsParser(&Pkg);
 131    bool const newError = _error->PendingError();
 132    _error->MergeWithStack();
 133    if (newError)
 134    {
 135       delete Parser;
 136       return nullptr;
 137    }
 138    else
 139       return Parser;
 140 }
 141                                                                         /*}}}*/
 142 // dpkg/status Index                                                    /*{{{*/
 143 debStatusIndex::debStatusIndex(std::string const &File) : pkgDebianIndexRealFile(File, true), d(NULL)
 144 {
 145 }
 146 std::string debStatusIndex::GetArchitecture() const
 147 {
 148    return std::string();
 149 }
 150 std::string debStatusIndex::GetComponent() const
 151 {
 152    return "now";
 153 }
 154 uint8_t debStatusIndex::GetIndexFlags() const
 155 {
 156    return pkgCache::Flag::NotSource;
 157 }
 158
 159 pkgCacheListParser * debStatusIndex::CreateListParser(FileFd &Pkg)
 160 {
 161    if (Pkg.IsOpen() == false)
 162       return nullptr;
 163    _error->PushToStack();
 164    pkgCacheListParser * const Parser = new debStatusListParser(&Pkg);
 165    bool const newError = _error->PendingError();
 166    _error->MergeWithStack();
 167    if (newError)
 168    {
 169       delete Parser;
 170       return nullptr;
 171    }
 172    else
 173       return Parser;
 174 }
 175                                                                         /*}}}*/
 176 // DebPkgFile Index - a single .deb file as an index                    /*{{{*/
 177 debDebPkgFileIndex::debDebPkgFileIndex(std::string const &DebFile)
 178    : pkgDebianIndexRealFile(DebFile, true), d(NULL), DebFile(DebFile)
 179 {
 180 }
 181 bool debDebPkgFileIndex::GetContent(std::ostream &content, std::string const &debfile)
 182 {
 183    struct stat Buf;
 184    if (stat(debfile.c_str(), &Buf) != 0)
 185       return false;
 186
 187    // get the control data out of the deb file via dpkg-deb -I
 188    std::string dpkg = _config->Find("Dir::Bin::dpkg","dpkg-deb");
 189    std::vector<const char *> Args;
 190    Args.push_back(dpkg.c_str());
 191    Args.push_back("-I");
 192    Args.push_back(debfile.c_str());
 193    Args.push_back("control");
 194    Args.push_back(NULL);
 195    FileFd PipeFd;
 196    pid_t Child;
 197    if(Popen((const char**)&Args[0], PipeFd, Child, FileFd::ReadOnly) == false)
 198       return _error->Error("Popen failed");
 199
 200    content << "Filename: " << debfile << "\n";
 201    content << "Size: " << std::to_string(Buf.st_size) << "\n";
 202    bool first_line_seen = false;
 203    char buffer[1024];
 204    do {
 205       unsigned long long actual = 0;
 206       if (PipeFd.Read(buffer, sizeof(buffer)-1, &actual) == false)
 207          return _error->Errno("read", "Failed to read dpkg pipe");
 208       if (actual == 0)
 209          break;
 210       buffer[actual] = '\0';
 211       char const * b = buffer;
 212       if (first_line_seen == false)
 213       {
 214          for (; *b != '\0' && (*b == '\n' || *b == '\r'); ++b)
 215             /* skip over leading newlines */;
 216          if (*b == '\0')
 217             continue;
 218          first_line_seen = true;
 219       }
 220       content << b;
 221    } while(true);
 222    ExecWait(Child, "Popen");
 223
 224    return true;
 225 }
 226 bool debDebPkgFileIndex::OpenListFile(FileFd &Pkg, std::string const &FileName)
 227 {
 228    // write the control data to a tempfile
 229    if (GetTempFile("deb-file-" + flNotDir(FileName), true, &Pkg) == NULL)
 230       return false;
 231    std::ostringstream content;
 232    if (GetContent(content, FileName) == false)
 233       return false;
 234    std::string const contentstr = content.str();
 235    if (contentstr.empty())
 236       return true;
 237    if (Pkg.Write(contentstr.c_str(), contentstr.length()) == false || Pkg.Seek(0) == false)
 238       return false;
 239    return true;
 240 }
 241 pkgCacheListParser * debDebPkgFileIndex::CreateListParser(FileFd &Pkg)
 242 {
 243    if (Pkg.IsOpen() == false)
 244       return nullptr;
 245    _error->PushToStack();
 246    pkgCacheListParser * const Parser = new debDebFileParser(&Pkg, DebFile);
 247    bool const newError = _error->PendingError();
 248    _error->MergeWithStack();
 249    if (newError)
 250    {
 251       delete Parser;
 252       return nullptr;
 253    }
 254    else
 255       return Parser;
 256 }
 257 uint8_t debDebPkgFileIndex::GetIndexFlags() const
 258 {
 259    return pkgCache::Flag::LocalSource;
 260 }
 261 std::string debDebPkgFileIndex::GetArchitecture() const
 262 {
 263    return std::string();
 264 }
 265 std::string debDebPkgFileIndex::GetComponent() const
 266 {
 267    return "local-deb";
 268 }
 269 pkgCache::PkgFileIterator debDebPkgFileIndex::FindInCache(pkgCache &Cache) const
 270 {
 271    std::string const FileName = IndexFileName();
 272    pkgCache::PkgFileIterator File = Cache.FileBegin();
 273    for (; File.end() == false; ++File)
 274    {
 275        if (File.FileName() == NULL || FileName != File.FileName())
 276          continue;
 277       // we can't do size checks here as file size != content size
 278       return File;
 279    }
 280
 281    return File;
 282 }
 283 std::string debDebPkgFileIndex::ArchiveInfo_impl(pkgCache::VerIterator const &Ver) const
 284 {
 285    std::string Res = IndexFileName() + " ";
 286    Res.append(Ver.ParentPkg().Name()).append(" ");
 287    Res.append(Ver.Arch()).append(" ");
 288    Res.append(Ver.VerStr());
 289    return Res;
 290 }
 291                                                                         /*}}}*/
 292 // DscFile Index - a single .dsc file as an index                       /*{{{*/
 293 debDscFileIndex::debDscFileIndex(std::string const &DscFile)
 294    : pkgDebianIndexRealFile(DscFile, true), d(NULL)
 295 {
 296 }
 297 pkgSrcRecords::Parser *debDscFileIndex::CreateSrcParser() const
 298 {
 299    if (Exists() == false)
 300       return NULL;
 301    return new debDscRecordParser(File, this);
 302 }
 303 std::string debDscFileIndex::GetComponent() const
 304 {
 305    return "local-dsc";
 306 }
 307 std::string debDscFileIndex::GetArchitecture() const
 308 {
 309    return "source";
 310 }
 311 uint8_t debDscFileIndex::GetIndexFlags() const
 312 {
 313    return pkgCache::Flag::LocalSource;
 314 }
 315                                                                         /*}}}*/
 316 // ControlFile Index - a directory with a debian/control file           /*{{{*/
 317 std::string debDebianSourceDirIndex::GetComponent() const
 318 {
 319    return "local-control";
 320 }
 321                                                                         /*}}}*/
 322 // String Package Index - a string of Packages file content             /*{{{*/
 323 std::string debStringPackageIndex::GetArchitecture() const
 324 {
 325    return std::string();
 326 }
 327 std::string debStringPackageIndex::GetComponent() const
 328 {
 329    return "apt-tmp-index";
 330 }
 331 uint8_t debStringPackageIndex::GetIndexFlags() const
 332 {
 333    return pkgCache::Flag::NotSource;
 334 }
 335 const pkgIndexFile::Type *debStringPackageIndex::GetType() const
 336 {
 337    return pkgIndexFile::Type::GetType("Debian Package Index");
 338 }
 339 debStringPackageIndex::debStringPackageIndex(std::string const &content) :
 340    pkgDebianIndexRealFile("", false), d(NULL)
 341 {
 342    char fn[1024];
 343    std::string const tempdir = GetTempDir();
 344    snprintf(fn, sizeof(fn), "%s/%s.XXXXXX", tempdir.c_str(), "apt-tmp-index");
 345    int const fd = mkstemp(fn);
 346    File = fn;
 347    FileFd::Write(fd, content.data(), content.length());
 348    close(fd);
 349 }
 350 debStringPackageIndex::~debStringPackageIndex()
 351 {
 352    RemoveFile("~debStringPackageIndex", File);
 353 }
 354                                                                         /*}}}*/
 355
 356 // Index File types for Debian                                          /*{{{*/
 357 class APT_HIDDEN debIFTypeSrc : public pkgIndexFile::Type
 358 {
 359    public:
 360    debIFTypeSrc() {Label = "Debian Source Index";};
 361 };
 362 class APT_HIDDEN debIFTypePkg : public pkgIndexFile::Type
 363 {
 364    public:
 365    virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator const &File) const APT_OVERRIDE
 366    {
 367       return new debRecordParser(File.FileName(),*File.Cache());
 368    };
 369    debIFTypePkg() {Label = "Debian Package Index";};
 370 };
 371 class APT_HIDDEN debIFTypeTrans : public debIFTypePkg
 372 {
 373    public:
 374    debIFTypeTrans() {Label = "Debian Translation Index";};
 375 };
 376 class APT_HIDDEN debIFTypeStatus : public pkgIndexFile::Type
 377 {
 378    public:
 379    virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator const &File) const APT_OVERRIDE
 380    {
 381       return new debRecordParser(File.FileName(),*File.Cache());
 382    };
 383    debIFTypeStatus() {Label = "Debian dpkg status file";};
 384 };
 385 class APT_HIDDEN debIFTypeDebPkgFile : public pkgIndexFile::Type
 386 {
 387    public:
 388    virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator const &File) const APT_OVERRIDE
 389    {
 390       return new debDebFileRecordParser(File.FileName());
 391    };
 392    debIFTypeDebPkgFile() {Label = "Debian deb file";};
 393 };
 394 class APT_HIDDEN debIFTypeDscFile : public pkgIndexFile::Type
 395 {
 396    public:
 397    virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string const &DscFile) const APT_OVERRIDE
 398    {
 399       return new debDscRecordParser(DscFile, NULL);
 400    };
 401    debIFTypeDscFile() {Label = "Debian dsc file";};
 402 };
 403 class APT_HIDDEN debIFTypeDebianSourceDir : public pkgIndexFile::Type
 404 {
 405    public:
 406    virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string const &SourceDir) const APT_OVERRIDE
 407    {
 408       return new debDscRecordParser(SourceDir + std::string("/debian/control"), NULL);
 409    };
 410    debIFTypeDebianSourceDir() {Label = "Debian control file";};
 411 };
 412
 413 APT_HIDDEN debIFTypeSrc _apt_Src;
 414 APT_HIDDEN debIFTypePkg _apt_Pkg;
 415 APT_HIDDEN debIFTypeTrans _apt_Trans;
 416 APT_HIDDEN debIFTypeStatus _apt_Status;
 417 APT_HIDDEN debIFTypeDebPkgFile _apt_DebPkgFile;
 418 // file based pseudo indexes
 419 APT_HIDDEN debIFTypeDscFile _apt_DscFile;
 420 APT_HIDDEN debIFTypeDebianSourceDir _apt_DebianSourceDir;
 421
 422 const pkgIndexFile::Type *debSourcesIndex::GetType() const
 423 {
 424    return &_apt_Src;
 425 }
 426 const pkgIndexFile::Type *debPackagesIndex::GetType() const
 427 {
 428    return &_apt_Pkg;
 429 }
 430 const pkgIndexFile::Type *debTranslationsIndex::GetType() const
 431 {
 432    return &_apt_Trans;
 433 }
 434 const pkgIndexFile::Type *debStatusIndex::GetType() const
 435 {
 436    return &_apt_Status;
 437 }
 438 const pkgIndexFile::Type *debDebPkgFileIndex::GetType() const
 439 {
 440    return &_apt_DebPkgFile;
 441 }
 442 const pkgIndexFile::Type *debDscFileIndex::GetType() const
 443 {
 444    return &_apt_DscFile;
 445 }
 446 const pkgIndexFile::Type *debDebianSourceDirIndex::GetType() const
 447 {
 448    return &_apt_DebianSourceDir;
 449 }
 450                                                                         /*}}}*/
 451
 452 debStatusIndex::~debStatusIndex() {}
 453 debPackagesIndex::~debPackagesIndex() {}
 454 debTranslationsIndex::~debTranslationsIndex() {}
 455 debSourcesIndex::~debSourcesIndex() {}
 456
 457 debDebPkgFileIndex::~debDebPkgFileIndex() {}
 458 debDscFileIndex::~debDscFileIndex() {}