apt-pkg/indexfile.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: indexfile.cc,v 1.2.2.1 2003/12/24 23:09:17 mdz Exp $
   4 /* ######################################################################
   5
   6    Index File - Abstraction for an index of archive/souce file.
   7
   8    ##################################################################### */
   9                                                                         /*}}}*/
  10 // Include Files                                                        /*{{{*/
  11 #include<config.h>
  12
  13 #include <apt-pkg/configuration.h>
  14 #include <apt-pkg/indexfile.h>
  15 #include <apt-pkg/error.h>
  16 #include <apt-pkg/fileutl.h>
  17 #include <apt-pkg/aptconfiguration.h>
  18 #include <apt-pkg/pkgcache.h>
  19 #include <apt-pkg/cacheiterators.h>
  20 #include <apt-pkg/srcrecords.h>
  21 #include <apt-pkg/macros.h>
  22
  23 #include <string>
  24 #include <vector>
  25 #include <clocale>
  26 #include <cstring>
  27                                                                         /*}}}*/
  28
  29 // Global list of Item supported
  30 static  pkgIndexFile::Type *ItmList[10];
  31 pkgIndexFile::Type **pkgIndexFile::Type::GlobalList = ItmList;
  32 unsigned long pkgIndexFile::Type::GlobalListLen = 0;
  33
  34 // Type::Type - Constructor                                             /*{{{*/
  35 // ---------------------------------------------------------------------
  36 /* */
  37 pkgIndexFile::Type::Type()
  38 {
  39    ItmList[GlobalListLen] = this;
  40    GlobalListLen++;
  41    Label = NULL;
  42 }
  43                                                                         /*}}}*/
  44 // Type::GetType - Locate the type by name                              /*{{{*/
  45 // ---------------------------------------------------------------------
  46 /* */
  47 pkgIndexFile::Type *pkgIndexFile::Type::GetType(const char *Type)
  48 {
  49    for (unsigned I = 0; I != GlobalListLen; I++)
  50       if (strcmp(GlobalList[I]->Label,Type) == 0)
  51          return GlobalList[I];
  52    return 0;
  53 }
  54                                                                         /*}}}*/
  55 pkgIndexFile::pkgIndexFile(bool Trusted) :                              /*{{{*/
  56    Trusted(Trusted)
  57 {
  58 }
  59                                                                         /*}}}*/
  60 // IndexFile::ArchiveInfo - Stub                                        /*{{{*/
  61 std::string pkgIndexFile::ArchiveInfo(pkgCache::VerIterator /*Ver*/) const
  62 {
  63    return std::string();
  64 }
  65                                                                         /*}}}*/
  66 // IndexFile::FindInCache - Stub                                        /*{{{*/
  67 pkgCache::PkgFileIterator pkgIndexFile::FindInCache(pkgCache &Cache) const
  68 {
  69    return pkgCache::PkgFileIterator(Cache);
  70 }
  71                                                                         /*}}}*/
  72 // IndexFile::SourceIndex - Stub                                        /*{{{*/
  73 std::string pkgIndexFile::SourceInfo(pkgSrcRecords::Parser const &/*Record*/,
  74                                 pkgSrcRecords::File const &/*File*/) const
  75 {
  76    return std::string();
  77 }
  78                                                                         /*}}}*/
  79 // IndexFile::TranslationsAvailable - Check if will use Translation     /*{{{*/
  80 // ---------------------------------------------------------------------
  81 /* */
  82 bool pkgIndexFile::TranslationsAvailable() {
  83         return (APT::Configuration::getLanguages().empty() != true);
  84 }
  85                                                                         /*}}}*/
  86 // IndexFile::CheckLanguageCode - Check the Language Code               /*{{{*/
  87 // ---------------------------------------------------------------------
  88 /* No intern need for this method anymore as the check for correctness
  89    is already done in getLanguages(). Note also that this check is
  90    rather bad (doesn't take three character like ast into account).
  91    TODO: Remove method with next API break */
  92 APT_DEPRECATED bool pkgIndexFile::CheckLanguageCode(const char *Lang)
  93 {
  94   if (strlen(Lang) == 2 || (strlen(Lang) == 5 && Lang[2] == '_'))
  95     return true;
  96
  97   if (strcmp(Lang,"C") != 0)
  98     _error->Warning("Wrong language code %s", Lang);
  99
 100   return false;
 101 }
 102                                                                         /*}}}*/
 103 // IndexFile::LanguageCode - Return the Language Code                   /*{{{*/
 104 // ---------------------------------------------------------------------
 105 /* As we have now possibly more than one LanguageCode this method is
 106    supersided by a) private classmembers or b) getLanguages().
 107    TODO: Remove method with next API break */
 108 APT_DEPRECATED std::string pkgIndexFile::LanguageCode() {
 109         if (TranslationsAvailable() == false)
 110                 return "";
 111         return APT::Configuration::getLanguages()[0];
 112 }
 113                                                                         /*}}}*/
 114
 115 // IndexTarget - Constructor                                            /*{{{*/
 116 IndexTarget::IndexTarget(std::string const &MetaKey, std::string const &ShortDesc,
 117       std::string const &LongDesc, std::string const &URI, bool const IsOptional,
 118       std::map<std::string, std::string> const &Options) :
 119    URI(URI), Description(LongDesc), ShortDesc(ShortDesc), MetaKey(MetaKey), IsOptional(IsOptional), Options(Options)
 120 {
 121 }
 122                                                                         /*}}}*/
 123 std::string IndexTarget::Option(OptionKeys const EnumKey) const         /*{{{*/
 124 {
 125    std::string Key;
 126    switch (EnumKey)
 127    {
 128 #define APT_CASE(X) case X: Key = #X; break
 129       APT_CASE(SITE);
 130       APT_CASE(RELEASE);
 131       APT_CASE(COMPONENT);
 132       APT_CASE(LANGUAGE);
 133       APT_CASE(ARCHITECTURE);
 134       APT_CASE(BASE_URI);
 135       APT_CASE(REPO_URI);
 136       APT_CASE(TARGET_OF);
 137       APT_CASE(CREATED_BY);
 138 #undef APT_CASE
 139       case FILENAME: return _config->FindDir("Dir::State::lists") + URItoFileName(URI);
 140       case EXISTING_FILENAME:
 141          std::string const filename = Option(FILENAME);
 142          std::vector<std::string> const types = APT::Configuration::getCompressionTypes();
 143          for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
 144          {
 145             if (t->empty())
 146                continue;
 147             std::string const file = (*t == "uncompressed") ? filename : (filename + "." + *t);
 148             if (FileExists(file))
 149                return file;
 150          }
 151          return "";
 152    }
 153    std::map<std::string,std::string>::const_iterator const M = Options.find(Key);
 154    if (M == Options.end())
 155       return "";
 156    return M->second;
 157 }
 158                                                                         /*}}}*/
 159 std::string IndexTarget::Format(std::string format) const               /*{{{*/
 160 {
 161    for (std::map<std::string, std::string>::const_iterator O = Options.begin(); O != Options.end(); ++O)
 162    {
 163       format = SubstVar(format, std::string("$(") + O->first + ")", O->second);
 164    }
 165    format = SubstVar(format, "$(METAKEY)", MetaKey);
 166    format = SubstVar(format, "$(SHORTDESC)", ShortDesc);
 167    format = SubstVar(format, "$(DESCRIPTION)", Description);
 168    format = SubstVar(format, "$(URI)", URI);
 169    format = SubstVar(format, "$(FILENAME)", Option(IndexTarget::FILENAME));
 170    return format;
 171 }
 172                                                                         /*}}}*/
 173
 174 pkgIndexTargetFile::pkgIndexTargetFile(IndexTarget const &Target, bool const Trusted) :/*{{{*/
 175    pkgIndexFile(Trusted), Target(Target)
 176 {
 177 }
 178                                                                         /*}}}*/
 179 std::string pkgIndexTargetFile::ArchiveURI(std::string File) const/*{{{*/
 180 {
 181    return Target.Option(IndexTarget::REPO_URI) + File;
 182 }
 183                                                                         /*}}}*/
 184 std::string pkgIndexTargetFile::Describe(bool Short) const              /*{{{*/
 185 {
 186    if (Short)
 187       return Target.Description;
 188    return Target.Description + " (" + IndexFileName() + ")";
 189 }
 190                                                                         /*}}}*/
 191 std::string pkgIndexTargetFile::IndexFileName() const                   /*{{{*/
 192 {
 193    std::string const s = Target.Option(IndexTarget::FILENAME);
 194    if (FileExists(s))
 195       return s;
 196
 197    std::vector<std::string> types = APT::Configuration::getCompressionTypes();
 198    for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
 199    {
 200       std::string p = s + '.' + *t;
 201       if (FileExists(p))
 202          return p;
 203    }
 204    return s;
 205 }
 206                                                                         /*}}}*/
 207 unsigned long pkgIndexTargetFile::Size() const                          /*{{{*/
 208 {
 209    unsigned long size = 0;
 210
 211    /* we need to ignore errors here; if the lists are absent, just return 0 */
 212    _error->PushToStack();
 213
 214    FileFd f(IndexFileName(), FileFd::ReadOnly, FileFd::Extension);
 215    if (!f.Failed())
 216       size = f.Size();
 217
 218    if (_error->PendingError() == true)
 219        size = 0;
 220    _error->RevertToStack();
 221
 222    return size;
 223 }
 224                                                                         /*}}}*/
 225 bool pkgIndexTargetFile::Exists() const                                 /*{{{*/
 226 {
 227    return FileExists(IndexFileName());
 228 }
 229                                                                         /*}}}*/