apt-pkg/deb/debrecords.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: debrecords.cc,v 1.10 2001/03/13 06:51:46 jgg Exp $
   4 /* ######################################################################
   5
   6    Debian Package Records - Parser for debian package records
   7
   8    ##################################################################### */
   9                                                                         /*}}}*/
  10 // Include Files                                                        /*{{{*/
  11 #include <config.h>
  12
  13 #include <apt-pkg/debrecords.h>
  14 #include <apt-pkg/strutl.h>
  15 #include <apt-pkg/aptconfiguration.h>
  16 #include <apt-pkg/fileutl.h>
  17 #include <apt-pkg/cacheiterators.h>
  18 #include <apt-pkg/pkgcache.h>
  19 #include <apt-pkg/tagfile.h>
  20
  21 #include <string.h>
  22 #include <algorithm>
  23 #include <string>
  24 #include <vector>
  25 #include <langinfo.h>
  26                                                                         /*}}}*/
  27
  28 using std::string;
  29
  30 // RecordParser::debRecordParser - Constructor                          /*{{{*/
  31 // ---------------------------------------------------------------------
  32 /* */
  33 debRecordParser::debRecordParser(string FileName,pkgCache &Cache) :
  34                   File(FileName,FileFd::ReadOnly, FileFd::Extension),
  35                   Tags(&File, std::max(Cache.Head().MaxVerFileSize,
  36                                        Cache.Head().MaxDescFileSize) + 200)
  37 {
  38 }
  39                                                                         /*}}}*/
  40 // RecordParser::Jump - Jump to a specific record                       /*{{{*/
  41 // ---------------------------------------------------------------------
  42 /* */
  43 bool debRecordParser::Jump(pkgCache::VerFileIterator const &Ver)
  44 {
  45    return Tags.Jump(Section,Ver->Offset);
  46 }
  47 bool debRecordParser::Jump(pkgCache::DescFileIterator const &Desc)
  48 {
  49    return Tags.Jump(Section,Desc->Offset);
  50 }
  51                                                                         /*}}}*/
  52 // RecordParser::FileName - Return the archive filename on the site     /*{{{*/
  53 // ---------------------------------------------------------------------
  54 /* */
  55 string debRecordParser::FileName()
  56 {
  57    return Section.FindS("Filename");
  58 }
  59                                                                         /*}}}*/
  60 // RecordParser::Name - Return the package name                         /*{{{*/
  61 // ---------------------------------------------------------------------
  62 /* */
  63 string debRecordParser::Name()
  64 {
  65    return Section.FindS("Package");
  66 }
  67                                                                         /*}}}*/
  68 // RecordParser::Homepage - Return the package homepage                 /*{{{*/
  69 // ---------------------------------------------------------------------
  70 /* */
  71 string debRecordParser::Homepage()
  72 {
  73    return Section.FindS("Homepage");
  74 }
  75                                                                         /*}}}*/
  76 // RecordParser::Hashes - return the available archive hashes           /*{{{*/
  77 HashStringList debRecordParser::Hashes() const
  78 {
  79    HashStringList hashes;
  80    for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type)
  81    {
  82       std::string const hash = Section.FindS(*type);
  83       if (hash.empty() == false)
  84          hashes.push_back(HashString(*type, hash));
  85    }
  86    return hashes;
  87 }
  88                                                                         /*}}}*/
  89 // RecordParser::Maintainer - Return the maintainer email               /*{{{*/
  90 // ---------------------------------------------------------------------
  91 /* */
  92 string debRecordParser::Maintainer()
  93 {
  94    return Section.FindS("Maintainer");
  95 }
  96                                                                         /*}}}*/
  97 // RecordParser::RecordField - Return the value of an arbitrary field       /*{{*/
  98 // ---------------------------------------------------------------------
  99 /* */
 100 string debRecordParser::RecordField(const char *fieldName)
 101 {
 102    return Section.FindS(fieldName);
 103 }
 104
 105                                                                         /*}}}*/
 106 // RecordParser::ShortDesc - Return a 1 line description                /*{{{*/
 107 // ---------------------------------------------------------------------
 108 /* */
 109 string debRecordParser::ShortDesc(std::string const &lang)
 110 {
 111    string const Res = LongDesc(lang);
 112    if (Res.empty() == true)
 113       return "";
 114    string::size_type const Pos = Res.find('\n');
 115    if (Pos == string::npos)
 116       return Res;
 117    return string(Res,0,Pos);
 118 }
 119                                                                         /*}}}*/
 120 // RecordParser::LongDesc - Return a longer description                 /*{{{*/
 121 // ---------------------------------------------------------------------
 122 /* */
 123 string debRecordParser::LongDesc(std::string const &lang)
 124 {
 125    string orig;
 126    if (lang.empty() == true)
 127    {
 128       std::vector<string> const lang = APT::Configuration::getLanguages();
 129       for (std::vector<string>::const_iterator l = lang.begin();
 130             l != lang.end(); ++l)
 131       {
 132          std::string const tagname = "Description-" + *l;
 133          orig = Section.FindS(tagname.c_str());
 134          if (orig.empty() == false)
 135             break;
 136          else if (*l == "en")
 137          {
 138             orig = Section.FindS("Description");
 139             if (orig.empty() == false)
 140                break;
 141          }
 142       }
 143       if (orig.empty() == true)
 144          orig = Section.FindS("Description");
 145    }
 146    else
 147    {
 148       std::string const tagname = "Description-" + lang;
 149       orig = Section.FindS(tagname.c_str());
 150       if (orig.empty() == true && lang == "en")
 151          orig = Section.FindS("Description");
 152    }
 153
 154    char const * const codeset = nl_langinfo(CODESET);
 155    if (strcmp(codeset,"UTF-8") != 0) {
 156       string dest;
 157       UTF8ToCodeset(codeset, orig, &dest);
 158       return dest;
 159    }
 160
 161    return orig;
 162 }
 163                                                                         /*}}}*/
 164
 165 static const char *SourceVerSeparators = " ()";
 166
 167 // RecordParser::SourcePkg - Return the source package name if any      /*{{{*/
 168 // ---------------------------------------------------------------------
 169 /* */
 170 string debRecordParser::SourcePkg()
 171 {
 172    string Res = Section.FindS("Source");
 173    string::size_type Pos = Res.find_first_of(SourceVerSeparators);
 174    if (Pos == string::npos)
 175       return Res;
 176    return string(Res,0,Pos);
 177 }
 178                                                                         /*}}}*/
 179 // RecordParser::SourceVer - Return the source version number if present        /*{{{*/
 180 // ---------------------------------------------------------------------
 181 /* */
 182 string debRecordParser::SourceVer()
 183 {
 184    string Pkg = Section.FindS("Source");
 185    string::size_type Pos = Pkg.find_first_of(SourceVerSeparators);
 186    if (Pos == string::npos)
 187       return "";
 188
 189    string::size_type VerStart = Pkg.find_first_not_of(SourceVerSeparators, Pos);
 190    if(VerStart == string::npos)
 191      return "";
 192
 193    string::size_type VerEnd = Pkg.find_first_of(SourceVerSeparators, VerStart);
 194    if(VerEnd == string::npos)
 195      // Corresponds to the case of, e.g., "foo (1.2" without a closing
 196      // paren.  Be liberal and guess what it means.
 197      return string(Pkg, VerStart);
 198    else
 199      return string(Pkg, VerStart, VerEnd - VerStart);
 200 }
 201                                                                         /*}}}*/
 202 // RecordParser::GetRec - Return the whole record                       /*{{{*/
 203 // ---------------------------------------------------------------------
 204 /* */
 205 void debRecordParser::GetRec(const char *&Start,const char *&Stop)
 206 {
 207    Section.GetSection(Start,Stop);
 208 }
 209                                                                         /*}}}*/
 210
 211 debRecordParser::~debRecordParser() {};