apt-pkg/deb/debindexfile.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: debindexfile.cc,v 1.2 2001/02/20 07:03:17 jgg 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 #ifdef __GNUG__
  13 #pragma implementation "apt-pkg/debindexfile.h"
  14 #endif
  15
  16 #include <apt-pkg/debindexfile.h>
  17 #include <apt-pkg/debsrcrecords.h>
  18 #include <apt-pkg/deblistparser.h>
  19 #include <apt-pkg/debrecords.h>
  20 #include <apt-pkg/sourcelist.h>
  21 #include <apt-pkg/configuration.h>
  22 #include <apt-pkg/progress.h>
  23 #include <apt-pkg/error.h>
  24 #include <apt-pkg/strutl.h>
  25 #include <apt-pkg/acquire-item.h>
  26
  27 #include <sys/stat.h>
  28                                                                         /*}}}*/
  29
  30 // SourcesIndex::debSourcesIndex - Constructor                          /*{{{*/
  31 // ---------------------------------------------------------------------
  32 /* */
  33 debSourcesIndex::debSourcesIndex(string URI,string Dist,string Section) :
  34                                      URI(URI), Dist(Dist), Section(Section)
  35 {
  36 }
  37                                                                         /*}}}*/
  38 // SourcesIndex::SourceInfo - Short 1 liner describing a source         /*{{{*/
  39 // ---------------------------------------------------------------------
  40 /* The result looks like:
  41      http://foo/ stable/main src 1.1.1 (dsc) */
  42 string debSourcesIndex::SourceInfo(pkgSrcRecords::Parser const &Record,
  43                                    pkgSrcRecords::File const &File) const
  44 {
  45    string Res;
  46    Res = ::URI::SiteOnly(URI) + ' ';
  47    if (Dist[Dist.size() - 1] == '/')
  48    {
  49       if (Dist != "/")
  50          Res += Dist;
  51    }
  52    else
  53       Res += Dist + '/' + Section;
  54
  55    Res += " ";
  56    Res += Record.Package();
  57    Res += " ";
  58    Res += Record.Version();
  59    if (File.Type.empty() == false)
  60       Res += " (" + File.Type + ")";
  61    return Res;
  62 }
  63                                                                         /*}}}*/
  64 // SourcesIndex::CreateSrcParser - Get a parser for the source files    /*{{{*/
  65 // ---------------------------------------------------------------------
  66 /* */
  67 pkgSrcRecords::Parser *debSourcesIndex::CreateSrcParser() const
  68 {
  69    string SourcesURI;
  70    if (Dist[Dist.size() - 1] == '/')
  71       SourcesURI = URI + Dist;
  72    else
  73       SourcesURI = URI + "dists/" + Dist + '/' + Section +
  74       "/source/";
  75
  76    SourcesURI += "Sources";
  77    SourcesURI = URItoFileName(SourcesURI);
  78    return new debSrcRecordParser(_config->FindDir("Dir::State::lists") +
  79                                  SourcesURI,this);
  80 }
  81                                                                         /*}}}*/
  82 // SourcesIndex::Describe - Give a descriptive path to the index        /*{{{*/
  83 // ---------------------------------------------------------------------
  84 /* */
  85 string debSourcesIndex::Describe() const
  86 {
  87    char S[300];
  88    snprintf(S,sizeof(S),"%s (%s)",Info("Packages").c_str(),
  89             IndexFile("Sources").c_str());
  90    return S;
  91 }
  92                                                                         /*}}}*/
  93 // SourcesIndex::Info - One liner describing the index URI              /*{{{*/
  94 // ---------------------------------------------------------------------
  95 /* */
  96 string debSourcesIndex::Info(const char *Type) const
  97 {
  98    string Info = ::URI::SiteOnly(URI) + ' ';
  99    if (Dist[Dist.size() - 1] == '/')
 100    {
 101       if (Dist != "/")
 102          Info += Dist;
 103    }
 104    else
 105       Info += Dist + '/' + Section;
 106    Info += " ";
 107    Info += Type;
 108    return Info;
 109 }
 110                                                                         /*}}}*/
 111 // SourcesIndex::Index* - Return the URI to the index files             /*{{{*/
 112 // ---------------------------------------------------------------------
 113 /* */
 114 inline string debSourcesIndex::IndexFile(const char *Type) const
 115 {
 116    return URItoFileName(IndexURI(Type));
 117 }
 118 string debSourcesIndex::IndexURI(const char *Type) const
 119 {
 120    string Res;
 121    if (Dist[Dist.size() - 1] == '/')
 122    {
 123       if (Dist != "/")
 124          Res = URI + Dist;
 125       else
 126          Res = URI;
 127    }
 128    else
 129       Res = URI + "dists/" + Dist + '/' + Section +
 130       "/source/";
 131
 132    Res += Type;
 133    return Res;
 134 }
 135                                                                         /*}}}*/
 136 // SourcesIndex::GetIndexes - Fetch the index files                     /*{{{*/
 137 // ---------------------------------------------------------------------
 138 /* */
 139 bool debSourcesIndex::GetIndexes(pkgAcquire *Owner) const
 140 {
 141    new pkgAcqIndex(Owner,IndexURI("Sources"),Info("Sources"),"Sources");
 142    new pkgAcqIndexRel(Owner,IndexURI("Release"),Info("Release"),"Release");
 143    return true;
 144 }
 145                                                                         /*}}}*/
 146 // SourcesIndex::Exists - Check if the index is available               /*{{{*/
 147 // ---------------------------------------------------------------------
 148 /* */
 149 bool debSourcesIndex::Exists() const
 150 {
 151    return FileExists(IndexFile("Sources"));
 152 }
 153                                                                         /*}}}*/
 154 // SourcesIndex::Size - Return the size of the index                    /*{{{*/
 155 // ---------------------------------------------------------------------
 156 /* */
 157 unsigned long debSourcesIndex::Size() const
 158 {
 159    struct stat S;
 160    if (stat(IndexFile("Sources").c_str(),&S) != 0)
 161       return 0;
 162    return S.st_size;
 163 }
 164                                                                         /*}}}*/
 165
 166 // PackagesIndex::debPackagesIndex - Contructor                         /*{{{*/
 167 // ---------------------------------------------------------------------
 168 /* */
 169 debPackagesIndex::debPackagesIndex(string URI,string Dist,string Section) :
 170                   URI(URI), Dist(Dist), Section(Section)
 171 {
 172 }
 173                                                                         /*}}}*/
 174 // PackagesIndex::ArchiveInfo - Short version of the archive url        /*{{{*/
 175 // ---------------------------------------------------------------------
 176 /* This is a shorter version that is designed to be < 60 chars or so */
 177 string debPackagesIndex::ArchiveInfo(pkgCache::VerIterator Ver) const
 178 {
 179    string Res = ::URI::SiteOnly(URI) + ' ';
 180    if (Dist[Dist.size() - 1] == '/')
 181    {
 182       if (Dist != "/")
 183          Res += Dist;
 184    }
 185    else
 186       Res += Dist + '/' + Section;
 187
 188    Res += " ";
 189    Res += Ver.ParentPkg().Name();
 190    Res += " ";
 191    Res += Ver.VerStr();
 192    return Res;
 193 }
 194                                                                         /*}}}*/
 195 // PackagesIndex::Describe - Give a descriptive path to the index       /*{{{*/
 196 // ---------------------------------------------------------------------
 197 /* This should help the user find the index in the sources.list and
 198    in the filesystem for problem solving */
 199 string debPackagesIndex::Describe() const
 200 {
 201    char S[300];
 202    snprintf(S,sizeof(S),"%s (%s)",Info("Packages").c_str(),
 203             IndexFile("Packages").c_str());
 204    return S;
 205 }
 206                                                                         /*}}}*/
 207 // PackagesIndex::Info - One liner describing the index URI             /*{{{*/
 208 // ---------------------------------------------------------------------
 209 /* */
 210 string debPackagesIndex::Info(const char *Type) const
 211 {
 212    string Info = ::URI::SiteOnly(URI) + ' ';
 213    if (Dist[Dist.size() - 1] == '/')
 214    {
 215       if (Dist != "/")
 216          Info += Dist;
 217    }
 218    else
 219       Info += Dist + '/' + Section;
 220    Info += " ";
 221    Info += Type;
 222    return Info;
 223 }
 224                                                                         /*}}}*/
 225 // PackagesIndex::Index* - Return the URI to the index files            /*{{{*/
 226 // ---------------------------------------------------------------------
 227 /* */
 228 inline string debPackagesIndex::IndexFile(const char *Type) const
 229 {
 230    return _config->FindDir("Dir::State::lists") + URItoFileName(IndexURI(Type));
 231 }
 232 string debPackagesIndex::IndexURI(const char *Type) const
 233 {
 234    string Res;
 235    if (Dist[Dist.size() - 1] == '/')
 236    {
 237       if (Dist != "/")
 238          Res = URI + Dist;
 239       else
 240          Res = URI;
 241    }
 242    else
 243       Res = URI + "dists/" + Dist + '/' + Section +
 244       "/binary-" + _config->Find("APT::Architecture") + '/';
 245
 246    Res += Type;
 247    return Res;
 248 }
 249                                                                         /*}}}*/
 250 // PackagesIndex::GetIndexes - Fetch the index files                    /*{{{*/
 251 // ---------------------------------------------------------------------
 252 /* */
 253 bool debPackagesIndex::GetIndexes(pkgAcquire *Owner) const
 254 {
 255    new pkgAcqIndex(Owner,IndexURI("Packages"),Info("Packages"),"Packages");
 256    new pkgAcqIndexRel(Owner,IndexURI("Release"),Info("Release"),"Release");
 257    return true;
 258 }
 259                                                                         /*}}}*/
 260 // PackagesIndex::Exists - Check if the index is available              /*{{{*/
 261 // ---------------------------------------------------------------------
 262 /* */
 263 bool debPackagesIndex::Exists() const
 264 {
 265    return FileExists(IndexFile("Packages"));
 266 }
 267                                                                         /*}}}*/
 268 // PackagesIndex::Size - Return the size of the index                   /*{{{*/
 269 // ---------------------------------------------------------------------
 270 /* This is really only used for progress reporting. */
 271 unsigned long debPackagesIndex::Size() const
 272 {
 273    struct stat S;
 274    if (stat(IndexFile("Packages").c_str(),&S) != 0)
 275       return 0;
 276    return S.st_size;
 277 }
 278                                                                         /*}}}*/
 279 // PackagesIndex::Merge - Load the index file into a cache              /*{{{*/
 280 // ---------------------------------------------------------------------
 281 /* */
 282 bool debPackagesIndex::Merge(pkgCacheGenerator &Gen,OpProgress &Prog) const
 283 {
 284    string PackageFile = IndexFile("Packages");
 285    FileFd Pkg(PackageFile,FileFd::ReadOnly);
 286    debListParser Parser(&Pkg);
 287    if (_error->PendingError() == true)
 288       return _error->Error("Problem opening %s",PackageFile.c_str());
 289
 290    Prog.SubProgress(0,Info("Packages"));
 291    ::URI Tmp(URI);
 292    if (Gen.SelectFile(PackageFile,Tmp.Host,*this) == false)
 293       return _error->Error("Problem with SelectFile %s",PackageFile.c_str());
 294
 295    // Store the IMS information
 296    pkgCache::PkgFileIterator File = Gen.GetCurFile();
 297    struct stat St;
 298    if (fstat(Pkg.Fd(),&St) != 0)
 299       return _error->Errno("fstat","Failed to stat");
 300    File->Size = St.st_size;
 301    File->mtime = St.st_mtime;
 302
 303    if (Gen.MergeList(Parser) == false)
 304       return _error->Error("Problem with MergeList %s",PackageFile.c_str());
 305
 306    // Check the release file
 307    string ReleaseFile = IndexFile("Release");
 308    if (FileExists(ReleaseFile) == true)
 309    {
 310       FileFd Rel(ReleaseFile,FileFd::ReadOnly);
 311       if (_error->PendingError() == true)
 312          return false;
 313       Parser.LoadReleaseInfo(File,Rel);
 314    }
 315
 316    return true;
 317 }
 318                                                                         /*}}}*/
 319 // PackagesIndex::FindInCache - Find this index                         /*{{{*/
 320 // ---------------------------------------------------------------------
 321 /* */
 322 pkgCache::PkgFileIterator debPackagesIndex::FindInCache(pkgCache &Cache) const
 323 {
 324    string FileName = IndexFile("Packages");
 325    pkgCache::PkgFileIterator File = Cache.FileBegin();
 326    for (; File.end() == false; File++)
 327    {
 328       if (FileName != File.FileName())
 329          continue;
 330
 331       struct stat St;
 332       if (stat(File.FileName(),&St) != 0)
 333          return pkgCache::PkgFileIterator(Cache);
 334       if ((unsigned)St.st_size != File->Size || St.st_mtime != File->mtime)
 335          return pkgCache::PkgFileIterator(Cache);
 336       return File;
 337    }
 338
 339    return File;
 340 }
 341                                                                         /*}}}*/
 342
 343 // StatusIndex::debStatusIndex - Constructor                            /*{{{*/
 344 // ---------------------------------------------------------------------
 345 /* */
 346 debStatusIndex::debStatusIndex(string File) : File(File)
 347 {
 348 }
 349                                                                         /*}}}*/
 350 // StatusIndex::Size - Return the size of the index                     /*{{{*/
 351 // ---------------------------------------------------------------------
 352 /* */
 353 unsigned long debStatusIndex::Size() const
 354 {
 355    struct stat S;
 356    if (stat(File.c_str(),&S) != 0)
 357       return 0;
 358    return S.st_size;
 359 }
 360                                                                         /*}}}*/
 361 // StatusIndex::Merge - Load the index file into a cache                /*{{{*/
 362 // ---------------------------------------------------------------------
 363 /* */
 364 bool debStatusIndex::Merge(pkgCacheGenerator &Gen,OpProgress &Prog) const
 365 {
 366    FileFd Pkg(File,FileFd::ReadOnly);
 367    if (_error->PendingError() == true)
 368       return false;
 369    debListParser Parser(&Pkg);
 370    if (_error->PendingError() == true)
 371       return false;
 372
 373    Prog.SubProgress(0,File);
 374    if (Gen.SelectFile(File,string(),*this,pkgCache::Flag::NotSource) == false)
 375       return _error->Error("Problem with SelectFile %s",File.c_str());
 376
 377    // Store the IMS information
 378    pkgCache::PkgFileIterator CFile = Gen.GetCurFile();
 379    struct stat St;
 380    if (fstat(Pkg.Fd(),&St) != 0)
 381       return _error->Errno("fstat","Failed to stat");
 382    CFile->Size = St.st_size;
 383    CFile->mtime = St.st_mtime;
 384    CFile->Archive = Gen.WriteUniqString("now");
 385
 386    if (Gen.MergeList(Parser) == false)
 387       return _error->Error("Problem with MergeList %s",File.c_str());
 388    return true;
 389 }
 390                                                                         /*}}}*/
 391 // StatusIndex::FindInCache - Find this index                           /*{{{*/
 392 // ---------------------------------------------------------------------
 393 /* */
 394 pkgCache::PkgFileIterator debStatusIndex::FindInCache(pkgCache &Cache) const
 395 {
 396    pkgCache::PkgFileIterator File = Cache.FileBegin();
 397    for (; File.end() == false; File++)
 398    {
 399       if (this->File != File.FileName())
 400          continue;
 401
 402       struct stat St;
 403       if (stat(File.FileName(),&St) != 0)
 404          return pkgCache::PkgFileIterator(Cache);
 405       if ((unsigned)St.st_size != File->Size || St.st_mtime != File->mtime)
 406          return pkgCache::PkgFileIterator(Cache);
 407       return File;
 408    }
 409    return File;
 410 }
 411                                                                         /*}}}*/
 412 // StatusIndex::Exists - Check if the index is available                /*{{{*/
 413 // ---------------------------------------------------------------------
 414 /* */
 415 bool debStatusIndex::Exists() const
 416 {
 417    // Abort if the file does not exist.
 418    return true;
 419 }
 420                                                                         /*}}}*/
 421
 422 // Source List types for Debian                                         /*{{{*/
 423 class debSLTypeDeb : public pkgSourceList::Type
 424 {
 425    public:
 426
 427    bool CreateItem(vector<pkgIndexFile *> &List,string URI,
 428                    string Dist,string Section) const
 429    {
 430       List.push_back(new debPackagesIndex(URI,Dist,Section));
 431       return true;
 432    };
 433
 434    debSLTypeDeb()
 435    {
 436       Name = "deb";
 437       Label = "Standard Debian binary tree";
 438    }
 439 };
 440
 441 class debSLTypeDebSrc : public pkgSourceList::Type
 442 {
 443    public:
 444
 445    bool CreateItem(vector<pkgIndexFile *> &List,string URI,
 446                    string Dist,string Section) const
 447    {
 448       List.push_back(new debSourcesIndex(URI,Dist,Section));
 449       return true;
 450    };
 451
 452    debSLTypeDebSrc()
 453    {
 454       Name = "deb-src";
 455       Label = "Standard Debian source tree";
 456    }
 457 };
 458
 459 debSLTypeDeb _apt_DebType;
 460 debSLTypeDebSrc _apt_DebSrcType;
 461                                                                         /*}}}*/
 462 // Index File types for Debian                                          /*{{{*/
 463 class debIFTypeSrc : public pkgIndexFile::Type
 464 {
 465    public:
 466
 467    debIFTypeSrc() {Label = "Debian Source Index";};
 468 };
 469 class debIFTypePkg : public pkgIndexFile::Type
 470 {
 471    public:
 472
 473    virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const
 474    {
 475       return new debRecordParser(File.FileName(),*File.Cache());
 476    };
 477    debIFTypePkg() {Label = "Debian Package Index";};
 478 };
 479 class debIFTypeStatus : public pkgIndexFile::Type
 480 {
 481    public:
 482
 483    virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const
 484    {
 485       return new debRecordParser(File.FileName(),*File.Cache());
 486    };
 487    debIFTypeStatus() {Label = "Debian dpkg status file";};
 488 };
 489 static debIFTypeSrc _apt_Src;
 490 static debIFTypePkg _apt_Pkg;
 491 static debIFTypeStatus _apt_Status;
 492
 493 const pkgIndexFile::Type *debSourcesIndex::GetType() const
 494 {
 495    return &_apt_Src;
 496 }
 497 const pkgIndexFile::Type *debPackagesIndex::GetType() const
 498 {
 499    return &_apt_Pkg;
 500 }
 501 const pkgIndexFile::Type *debStatusIndex::GetType() const
 502 {
 503    return &_apt_Status;
 504 }
 505
 506                                                                         /*}}}*/