German translation proof read by Helge Kreutzmann

[apt.git] / apt-pkg / deb / debrecords.cc

diff --git a/apt-pkg/deb/debrecords.cc b/apt-pkg/deb/debrecords.cc
index 4dfc8b56a8a5103fd6a30a8314b7ce3e5b519647..a132f34a6d95182879830e7c5b0712c64b890a32 100644 (file)
--- a/apt-pkg/deb/debrecords.cc
+++ b/apt-pkg/deb/debrecords.cc
@@ -11,152 +11,161 @@
 #include <config.h>
 
 #include <apt-pkg/debrecords.h>
 #include <config.h>
 
 #include <apt-pkg/debrecords.h>

+#include <apt-pkg/debindexfile.h>

 #include <apt-pkg/strutl.h>
 #include <apt-pkg/strutl.h>

-#include <apt-pkg/error.h>

 #include <apt-pkg/aptconfiguration.h>
 #include <apt-pkg/aptconfiguration.h>

+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/cacheiterators.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/tagfile.h>
+#include <apt-pkg/error.h>
+
+#include <string.h>
+#include <algorithm>
+#include <sstream>
+#include <string>
+#include <vector>

 #include <langinfo.h>
 #include <langinfo.h>

+
+#include <apti18n.h>

                                                                        /*}}}*/
 
                                                                        /*}}}*/
 

+using std::string;
+

 // RecordParser::debRecordParser - Constructor                         /*{{{*/
 // RecordParser::debRecordParser - Constructor                         /*{{{*/

-// ---------------------------------------------------------------------
-/* */
-debRecordParser::debRecordParser(string FileName,pkgCache &Cache) : 
-                  File(FileName,FileFd::ReadOnlyGzip), 
-                  Tags(&File, std::max(Cache.Head().MaxVerFileSize, 
-                                      Cache.Head().MaxDescFileSize) + 200)
+debRecordParser::debRecordParser(string FileName,pkgCache &Cache) :
+   debRecordParserBase(), d(NULL), File(FileName, FileFd::ReadOnly, FileFd::Extension),
+   Tags(&File, std::max(Cache.Head().MaxVerFileSize, Cache.Head().MaxDescFileSize) + 200)

 {
 }
                                                                        /*}}}*/
 // RecordParser::Jump - Jump to a specific record                      /*{{{*/
 {
 }
                                                                        /*}}}*/
 // RecordParser::Jump - Jump to a specific record                      /*{{{*/

-// ---------------------------------------------------------------------
-/* */

 bool debRecordParser::Jump(pkgCache::VerFileIterator const &Ver)
 {
 bool debRecordParser::Jump(pkgCache::VerFileIterator const &Ver)
 {

+   if (Ver.end() == true)
+      return false;

    return Tags.Jump(Section,Ver->Offset);
 }
 bool debRecordParser::Jump(pkgCache::DescFileIterator const &Desc)
 {
    return Tags.Jump(Section,Ver->Offset);
 }
 bool debRecordParser::Jump(pkgCache::DescFileIterator const &Desc)
 {

+   if (Desc.end() == true)
+      return false;

    return Tags.Jump(Section,Desc->Offset);
 }
                                                                        /*}}}*/
    return Tags.Jump(Section,Desc->Offset);
 }
                                                                        /*}}}*/

-// RecordParser::FileName - Return the archive filename on the site    /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-string debRecordParser::FileName()
+debRecordParser::~debRecordParser() {}
+
+debRecordParserBase::debRecordParserBase() : Parser(), d(NULL) {}
+// RecordParserBase::FileName - Return the archive filename on the site        /*{{{*/
+string debRecordParserBase::FileName()

 {
    return Section.FindS("Filename");
 }
                                                                        /*}}}*/
 {
    return Section.FindS("Filename");
 }
                                                                        /*}}}*/

-// RecordParser::Name - Return the package name                                /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-string debRecordParser::Name()
+// RecordParserBase::Name - Return the package name                    /*{{{*/
+string debRecordParserBase::Name()

 {
 {

-   return Section.FindS("Package");
+   string Result = Section.FindS("Package");
+
+   // Normalize mixed case package names to lower case, like dpkg does
+   // See Bug#807012 for details
+   std::transform(Result.begin(), Result.end(), Result.begin(), tolower_ascii);
+
+   return Result;

 }
                                                                        /*}}}*/
 }
                                                                        /*}}}*/

-// RecordParser::Homepage - Return the package homepage                        /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-string debRecordParser::Homepage()
+// RecordParserBase::Homepage - Return the package homepage            /*{{{*/
+string debRecordParserBase::Homepage()

 {
    return Section.FindS("Homepage");
 }
                                                                        /*}}}*/
 {
    return Section.FindS("Homepage");
 }
                                                                        /*}}}*/

-// RecordParser::MD5Hash - Return the archive hash                     /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-string debRecordParser::MD5Hash()
-{
-   return Section.FindS("MD5Sum");
-}
-                                                                       /*}}}*/
-// RecordParser::SHA1Hash - Return the archive hash                    /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-string debRecordParser::SHA1Hash()
-{
-   return Section.FindS("SHA1");
-}
-                                                                       /*}}}*/
-// RecordParser::SHA256Hash - Return the archive hash                  /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-string debRecordParser::SHA256Hash()
-{
-   return Section.FindS("SHA256");
-}
-                                                                       /*}}}*/
-// RecordParser::SHA512Hash - Return the archive hash                  /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-string debRecordParser::SHA512Hash()
+// RecordParserBase::Hashes - return the available archive hashes      /*{{{*/
+HashStringList debRecordParserBase::Hashes() const

 {
 {

-   return Section.FindS("SHA512");
+   HashStringList hashes;
+   for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type)
+   {
+      std::string const hash = Section.FindS(*type);
+      if (hash.empty() == false)
+        hashes.push_back(HashString(*type, hash));
+   }
+   auto const size = Section.FindULL("Size", 0);
+   if (size != 0)
+      hashes.FileSize(size);
+   return hashes;

 }
                                                                        /*}}}*/
 }
                                                                        /*}}}*/

-// RecordParser::Maintainer - Return the maintainer email              /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-string debRecordParser::Maintainer()
+// RecordParserBase::Maintainer - Return the maintainer email          /*{{{*/
+string debRecordParserBase::Maintainer()

 {
    return Section.FindS("Maintainer");
 }
                                                                        /*}}}*/
 {
    return Section.FindS("Maintainer");
 }
                                                                        /*}}}*/

-// RecordParser::RecordField - Return the value of an arbitrary field       /*{{*/
-// ---------------------------------------------------------------------
-/* */
-string debRecordParser::RecordField(const char *fieldName)
+// RecordParserBase::RecordField - Return the value of an arbitrary field      /*{{*/
+string debRecordParserBase::RecordField(const char *fieldName)

 {
    return Section.FindS(fieldName);
 }
 {
    return Section.FindS(fieldName);
 }

-
-                                                                        /*}}}*/
-// RecordParser::ShortDesc - Return a 1 line description               /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-string debRecordParser::ShortDesc()
+                                                                       /*}}}*/
+// RecordParserBase::ShortDesc - Return a 1 line description           /*{{{*/
+string debRecordParserBase::ShortDesc(std::string const &lang)

 {
 {

-   string Res = LongDesc();
-   string::size_type Pos = Res.find('\n');
+   string const Res = LongDesc(lang);
+   if (Res.empty() == true)
+      return "";
+   string::size_type const Pos = Res.find('\n');

    if (Pos == string::npos)
       return Res;
    return string(Res,0,Pos);
 }
                                                                        /*}}}*/
    if (Pos == string::npos)
       return Res;
    return string(Res,0,Pos);
 }
                                                                        /*}}}*/

-// RecordParser::LongDesc - Return a longer description                        /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-string debRecordParser::LongDesc()
-{
-  string orig, dest;
-
-  if (!Section.FindS("Description").empty())
-     orig = Section.FindS("Description").c_str();
-  else
-  {
-     vector<string> const lang = APT::Configuration::getLanguages();
-     for (vector<string>::const_iterator l = lang.begin();
-         orig.empty() && l != lang.end(); ++l)
-       orig = Section.FindS(string("Description-").append(*l).c_str());
-  }
-
-  char const * const codeset = nl_langinfo(CODESET);
-  if (strcmp(codeset,"UTF-8") != 0) {
-     UTF8ToCodeset(codeset, orig, &dest);
-     orig = dest;
-   }    
-  
+// RecordParserBase::LongDesc - Return a longer description            /*{{{*/
+string debRecordParserBase::LongDesc(std::string const &lang)
+{
+   string orig;
+   if (lang.empty() == true)
+   {
+      std::vector<string> const lang = APT::Configuration::getLanguages();
+      for (std::vector<string>::const_iterator l = lang.begin();
+           l != lang.end(); ++l)
+      {
+        std::string const tagname = "Description-" + *l;
+        orig = Section.FindS(tagname.c_str());
+        if (orig.empty() == false)
+           break;
+        else if (*l == "en")
+        {
+           orig = Section.FindS("Description");
+           if (orig.empty() == false)
+              break;
+        }
+      }
+      if (orig.empty() == true)
+        orig = Section.FindS("Description");
+   }
+   else
+   {
+      std::string const tagname = "Description-" + lang;
+      orig = Section.FindS(tagname.c_str());
+      if (orig.empty() == true && lang == "en")
+        orig = Section.FindS("Description");
+   }
+
+   char const * const codeset = nl_langinfo(CODESET);
+   if (strcmp(codeset,"UTF-8") != 0) {
+      string dest;
+      UTF8ToCodeset(codeset, orig, &dest);
+      return dest;
+   }
+

    return orig;
 }
                                                                        /*}}}*/
 
    return orig;
 }
                                                                        /*}}}*/
 

-static const char *SourceVerSeparators = " ()";
-
-// RecordParser::SourcePkg - Return the source package name if any     /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-string debRecordParser::SourcePkg()
+static const char * const SourceVerSeparators = " ()";
+// RecordParserBase::SourcePkg - Return the source package name if any /*{{{*/
+string debRecordParserBase::SourcePkg()

 {
    string Res = Section.FindS("Source");
    string::size_type Pos = Res.find_first_of(SourceVerSeparators);
 {
    string Res = Section.FindS("Source");
    string::size_type Pos = Res.find_first_of(SourceVerSeparators);


@@ -165,10 +174,8 @@ string debRecordParser::SourcePkg()
    return string(Res,0,Pos);
 }
                                                                        /*}}}*/
    return string(Res,0,Pos);
 }
                                                                        /*}}}*/

-// RecordParser::SourceVer - Return the source version number if present       /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-string debRecordParser::SourceVer()
+// RecordParserBase::SourceVer - Return the source version number if present   /*{{{*/
+string debRecordParserBase::SourceVer()

 {
    string Pkg = Section.FindS("Source");
    string::size_type Pos = Pkg.find_first_of(SourceVerSeparators);
 {
    string Pkg = Section.FindS("Source");
    string::size_type Pos = Pkg.find_first_of(SourceVerSeparators);


@@ -188,11 +195,35 @@ string debRecordParser::SourceVer()
      return string(Pkg, VerStart, VerEnd - VerStart);
 }
                                                                        /*}}}*/
      return string(Pkg, VerStart, VerEnd - VerStart);
 }
                                                                        /*}}}*/

-// RecordParser::GetRec - Return the whole record                      /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-void debRecordParser::GetRec(const char *&Start,const char *&Stop)
+// RecordParserBase::GetRec - Return the whole record                  /*{{{*/
+void debRecordParserBase::GetRec(const char *&Start,const char *&Stop)

 {
    Section.GetSection(Start,Stop);
 }
                                                                        /*}}}*/
 {
    Section.GetSection(Start,Stop);
 }
                                                                        /*}}}*/

+debRecordParserBase::~debRecordParserBase() {}
+
+bool debDebFileRecordParser::LoadContent()
+{
+   // load content only once
+   if (controlContent.empty() == false)
+      return true;
+
+   std::ostringstream content;
+   if (debDebPkgFileIndex::GetContent(content, debFileName) == false)
+      return false;
+   // add two newlines to make sure the scanner finds the section,
+   // which is usually done by pkgTagFile automatically if needed.
+   content << "\n\n";
+
+   controlContent = content.str();
+   if (Section.Scan(controlContent.c_str(), controlContent.length()) == false)
+      return _error->Error(_("Unable to parse package file %s (%d)"), debFileName.c_str(), 3);
+   return true;
+}
+bool debDebFileRecordParser::Jump(pkgCache::VerFileIterator const &) { return LoadContent(); }
+bool debDebFileRecordParser::Jump(pkgCache::DescFileIterator const &) { return LoadContent(); }
+std::string debDebFileRecordParser::FileName() { return debFileName; }
+
+debDebFileRecordParser::debDebFileRecordParser(std::string FileName) : debRecordParserBase(), d(NULL), debFileName(FileName) {}
+debDebFileRecordParser::~debDebFileRecordParser() {}