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/debindexfile.h>
  15 #include <apt-pkg/strutl.h>
  16 #include <apt-pkg/aptconfiguration.h>
  17 #include <apt-pkg/fileutl.h>
  18 #include <apt-pkg/cacheiterators.h>
  19 #include <apt-pkg/pkgcache.h>
  20 #include <apt-pkg/tagfile.h>
  21 #include <apt-pkg/error.h>
  22
  23 #include <string.h>
  24 #include <algorithm>
  25 #include <sstream>
  26 #include <string>
  27 #include <vector>
  28 #include <langinfo.h>
  29
  30 #include <apti18n.h>
  31                                                                         /*}}}*/
  32
  33 using std::string;
  34
  35 // RecordParser::debRecordParser - Constructor                          /*{{{*/
  36 debRecordParser::debRecordParser(string FileName,pkgCache &Cache) :
  37    debRecordParserBase(), d(NULL), File(FileName, FileFd::ReadOnly, FileFd::Extension),
  38    Tags(&File, std::max(Cache.Head().MaxVerFileSize, Cache.Head().MaxDescFileSize) + 200)
  39 {
  40 }
  41                                                                         /*}}}*/
  42 // RecordParser::Jump - Jump to a specific record                       /*{{{*/
  43 bool debRecordParser::Jump(pkgCache::VerFileIterator const &Ver)
  44 {
  45    if (Ver.end() == true)
  46       return false;
  47    return Tags.Jump(Section,Ver->Offset);
  48 }
  49 bool debRecordParser::Jump(pkgCache::DescFileIterator const &Desc)
  50 {
  51    if (Desc.end() == true)
  52       return false;
  53    return Tags.Jump(Section,Desc->Offset);
  54 }
  55                                                                         /*}}}*/
  56 debRecordParser::~debRecordParser() {}
  57
  58 debRecordParserBase::debRecordParserBase() : Parser(), d(NULL) {}
  59 // RecordParserBase::FileName - Return the archive filename on the site /*{{{*/
  60 string debRecordParserBase::FileName()
  61 {
  62    return Section.FindS("Filename");
  63 }
  64                                                                         /*}}}*/
  65 // RecordParserBase::Name - Return the package name                     /*{{{*/
  66 string debRecordParserBase::Name()
  67 {
  68    string Result = Section.FindS("Package");
  69
  70    // Normalize mixed case package names to lower case, like dpkg does
  71    // See Bug#807012 for details
  72    std::transform(Result.begin(), Result.end(), Result.begin(), tolower_ascii);
  73
  74    return Result;
  75 }
  76                                                                         /*}}}*/
  77 // RecordParserBase::Homepage - Return the package homepage             /*{{{*/
  78 string debRecordParserBase::Homepage()
  79 {
  80    return Section.FindS("Homepage");
  81 }
  82                                                                         /*}}}*/
  83 // RecordParserBase::Hashes - return the available archive hashes       /*{{{*/
  84 HashStringList debRecordParserBase::Hashes() const
  85 {
  86    HashStringList hashes;
  87    for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type)
  88    {
  89       std::string const hash = Section.FindS(*type);
  90       if (hash.empty() == false)
  91          hashes.push_back(HashString(*type, hash));
  92    }
  93    return hashes;
  94 }
  95                                                                         /*}}}*/
  96 // RecordParserBase::Maintainer - Return the maintainer email           /*{{{*/
  97 string debRecordParserBase::Maintainer()
  98 {
  99    return Section.FindS("Maintainer");
 100 }
 101                                                                         /*}}}*/
 102 // RecordParserBase::RecordField - Return the value of an arbitrary field       /*{{*/
 103 string debRecordParserBase::RecordField(const char *fieldName)
 104 {
 105    return Section.FindS(fieldName);
 106 }
 107                                                                         /*}}}*/
 108 // RecordParserBase::ShortDesc - Return a 1 line description            /*{{{*/
 109 string debRecordParserBase::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 // RecordParserBase::LongDesc - Return a longer description             /*{{{*/
 121 string debRecordParserBase::LongDesc(std::string const &lang)
 122 {
 123    string orig;
 124    if (lang.empty() == true)
 125    {
 126       std::vector<string> const lang = APT::Configuration::getLanguages();
 127       for (std::vector<string>::const_iterator l = lang.begin();
 128             l != lang.end(); ++l)
 129       {
 130          std::string const tagname = "Description-" + *l;
 131          orig = Section.FindS(tagname.c_str());
 132          if (orig.empty() == false)
 133             break;
 134          else if (*l == "en")
 135          {
 136             orig = Section.FindS("Description");
 137             if (orig.empty() == false)
 138                break;
 139          }
 140       }
 141       if (orig.empty() == true)
 142          orig = Section.FindS("Description");
 143    }
 144    else
 145    {
 146       std::string const tagname = "Description-" + lang;
 147       orig = Section.FindS(tagname.c_str());
 148       if (orig.empty() == true && lang == "en")
 149          orig = Section.FindS("Description");
 150    }
 151
 152    char const * const codeset = nl_langinfo(CODESET);
 153    if (strcmp(codeset,"UTF-8") != 0) {
 154       string dest;
 155       UTF8ToCodeset(codeset, orig, &dest);
 156       return dest;
 157    }
 158
 159    return orig;
 160 }
 161                                                                         /*}}}*/
 162
 163 static const char * const SourceVerSeparators = " ()";
 164 // RecordParserBase::SourcePkg - Return the source package name if any  /*{{{*/
 165 string debRecordParserBase::SourcePkg()
 166 {
 167    string Res = Section.FindS("Source");
 168    string::size_type Pos = Res.find_first_of(SourceVerSeparators);
 169    if (Pos == string::npos)
 170       return Res;
 171    return string(Res,0,Pos);
 172 }
 173                                                                         /*}}}*/
 174 // RecordParserBase::SourceVer - Return the source version number if present    /*{{{*/
 175 string debRecordParserBase::SourceVer()
 176 {
 177    string Pkg = Section.FindS("Source");
 178    string::size_type Pos = Pkg.find_first_of(SourceVerSeparators);
 179    if (Pos == string::npos)
 180       return "";
 181
 182    string::size_type VerStart = Pkg.find_first_not_of(SourceVerSeparators, Pos);
 183    if(VerStart == string::npos)
 184      return "";
 185
 186    string::size_type VerEnd = Pkg.find_first_of(SourceVerSeparators, VerStart);
 187    if(VerEnd == string::npos)
 188      // Corresponds to the case of, e.g., "foo (1.2" without a closing
 189      // paren.  Be liberal and guess what it means.
 190      return string(Pkg, VerStart);
 191    else
 192      return string(Pkg, VerStart, VerEnd - VerStart);
 193 }
 194                                                                         /*}}}*/
 195 // RecordParserBase::GetRec - Return the whole record                   /*{{{*/
 196 void debRecordParserBase::GetRec(const char *&Start,const char *&Stop)
 197 {
 198    Section.GetSection(Start,Stop);
 199 }
 200                                                                         /*}}}*/
 201 debRecordParserBase::~debRecordParserBase() {}
 202
 203 bool debDebFileRecordParser::LoadContent()
 204 {
 205    // load content only once
 206    if (controlContent.empty() == false)
 207       return true;
 208
 209    std::ostringstream content;
 210    if (debDebPkgFileIndex::GetContent(content, debFileName) == false)
 211       return false;
 212    // add two newlines to make sure the scanner finds the section,
 213    // which is usually done by pkgTagFile automatically if needed.
 214    content << "\n\n";
 215
 216    controlContent = content.str();
 217    if (Section.Scan(controlContent.c_str(), controlContent.length()) == false)
 218       return _error->Error(_("Unable to parse package file %s (%d)"), debFileName.c_str(), 3);
 219    return true;
 220 }
 221 bool debDebFileRecordParser::Jump(pkgCache::VerFileIterator const &) { return LoadContent(); }
 222 bool debDebFileRecordParser::Jump(pkgCache::DescFileIterator const &) { return LoadContent(); }
 223 std::string debDebFileRecordParser::FileName() { return debFileName; }
 224
 225 debDebFileRecordParser::debDebFileRecordParser(std::string FileName) : debRecordParserBase(), d(NULL), debFileName(FileName) {}
 226 debDebFileRecordParser::~debDebFileRecordParser() {}