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    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 debRecordParser::~debRecordParser() {}
  53
  54 debRecordParserBase::debRecordParserBase() : Parser(), d(NULL) {}
  55 // RecordParserBase::FileName - Return the archive filename on the site /*{{{*/
  56 string debRecordParserBase::FileName()
  57 {
  58    return Section.FindS("Filename");
  59 }
  60                                                                         /*}}}*/
  61 // RecordParserBase::Name - Return the package name                     /*{{{*/
  62 string debRecordParserBase::Name()
  63 {
  64    return Section.FindS("Package");
  65 }
  66                                                                         /*}}}*/
  67 // RecordParserBase::Homepage - Return the package homepage             /*{{{*/
  68 string debRecordParserBase::Homepage()
  69 {
  70    return Section.FindS("Homepage");
  71 }
  72                                                                         /*}}}*/
  73 // RecordParserBase::Hashes - return the available archive hashes       /*{{{*/
  74 HashStringList debRecordParserBase::Hashes() const
  75 {
  76    HashStringList hashes;
  77    for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type)
  78    {
  79       std::string const hash = Section.FindS(*type);
  80       if (hash.empty() == false)
  81          hashes.push_back(HashString(*type, hash));
  82    }
  83    return hashes;
  84 }
  85                                                                         /*}}}*/
  86 // RecordParserBase::Maintainer - Return the maintainer email           /*{{{*/
  87 string debRecordParserBase::Maintainer()
  88 {
  89    return Section.FindS("Maintainer");
  90 }
  91                                                                         /*}}}*/
  92 // RecordParserBase::RecordField - Return the value of an arbitrary field       /*{{*/
  93 string debRecordParserBase::RecordField(const char *fieldName)
  94 {
  95    return Section.FindS(fieldName);
  96 }
  97                                                                         /*}}}*/
  98 // RecordParserBase::ShortDesc - Return a 1 line description            /*{{{*/
  99 string debRecordParserBase::ShortDesc(std::string const &lang)
 100 {
 101    string const Res = LongDesc(lang);
 102    if (Res.empty() == true)
 103       return "";
 104    string::size_type const Pos = Res.find('\n');
 105    if (Pos == string::npos)
 106       return Res;
 107    return string(Res,0,Pos);
 108 }
 109                                                                         /*}}}*/
 110 // RecordParserBase::LongDesc - Return a longer description             /*{{{*/
 111 string debRecordParserBase::LongDesc(std::string const &lang)
 112 {
 113    string orig;
 114    if (lang.empty() == true)
 115    {
 116       std::vector<string> const lang = APT::Configuration::getLanguages();
 117       for (std::vector<string>::const_iterator l = lang.begin();
 118             l != lang.end(); ++l)
 119       {
 120          std::string const tagname = "Description-" + *l;
 121          orig = Section.FindS(tagname.c_str());
 122          if (orig.empty() == false)
 123             break;
 124          else if (*l == "en")
 125          {
 126             orig = Section.FindS("Description");
 127             if (orig.empty() == false)
 128                break;
 129          }
 130       }
 131       if (orig.empty() == true)
 132          orig = Section.FindS("Description");
 133    }
 134    else
 135    {
 136       std::string const tagname = "Description-" + lang;
 137       orig = Section.FindS(tagname.c_str());
 138       if (orig.empty() == true && lang == "en")
 139          orig = Section.FindS("Description");
 140    }
 141
 142    char const * const codeset = nl_langinfo(CODESET);
 143    if (strcmp(codeset,"UTF-8") != 0) {
 144       string dest;
 145       UTF8ToCodeset(codeset, orig, &dest);
 146       return dest;
 147    }
 148
 149    return orig;
 150 }
 151                                                                         /*}}}*/
 152
 153 static const char * const SourceVerSeparators = " ()";
 154 // RecordParserBase::SourcePkg - Return the source package name if any  /*{{{*/
 155 string debRecordParserBase::SourcePkg()
 156 {
 157    string Res = Section.FindS("Source");
 158    string::size_type Pos = Res.find_first_of(SourceVerSeparators);
 159    if (Pos == string::npos)
 160       return Res;
 161    return string(Res,0,Pos);
 162 }
 163                                                                         /*}}}*/
 164 // RecordParserBase::SourceVer - Return the source version number if present    /*{{{*/
 165 string debRecordParserBase::SourceVer()
 166 {
 167    string Pkg = Section.FindS("Source");
 168    string::size_type Pos = Pkg.find_first_of(SourceVerSeparators);
 169    if (Pos == string::npos)
 170       return "";
 171
 172    string::size_type VerStart = Pkg.find_first_not_of(SourceVerSeparators, Pos);
 173    if(VerStart == string::npos)
 174      return "";
 175
 176    string::size_type VerEnd = Pkg.find_first_of(SourceVerSeparators, VerStart);
 177    if(VerEnd == string::npos)
 178      // Corresponds to the case of, e.g., "foo (1.2" without a closing
 179      // paren.  Be liberal and guess what it means.
 180      return string(Pkg, VerStart);
 181    else
 182      return string(Pkg, VerStart, VerEnd - VerStart);
 183 }
 184                                                                         /*}}}*/
 185 // RecordParserBase::GetRec - Return the whole record                   /*{{{*/
 186 void debRecordParserBase::GetRec(const char *&Start,const char *&Stop)
 187 {
 188    Section.GetSection(Start,Stop);
 189 }
 190                                                                         /*}}}*/
 191 debRecordParserBase::~debRecordParserBase() {}
 192
 193 bool debDebFileRecordParser::LoadContent()
 194 {
 195    // load content only once
 196    if (controlContent.empty() == false)
 197       return true;
 198
 199    std::ostringstream content;
 200    if (debDebPkgFileIndex::GetContent(content, debFileName) == false)
 201       return false;
 202    // add two newlines to make sure the scanner finds the section,
 203    // which is usually done by pkgTagFile automatically if needed.
 204    content << "\n\n";
 205
 206    controlContent = content.str();
 207    if (Section.Scan(controlContent.c_str(), controlContent.length()) == false)
 208       return _error->Error(_("Unable to parse package file %s (%d)"), debFileName.c_str(), 3);
 209    return true;
 210 }
 211 bool debDebFileRecordParser::Jump(pkgCache::VerFileIterator const &) { return LoadContent(); }
 212 bool debDebFileRecordParser::Jump(pkgCache::DescFileIterator const &) { return LoadContent(); }
 213 std::string debDebFileRecordParser::FileName() { return debFileName; }
 214
 215 debDebFileRecordParser::debDebFileRecordParser(std::string FileName) : debRecordParserBase(), d(NULL), debFileName(FileName) {}
 216 debDebFileRecordParser::~debDebFileRecordParser() {}