Merge bzip2-debs branch

[apt.git] / apt-pkg / acquire-item.cc

diff --git a/apt-pkg/acquire-item.cc b/apt-pkg/acquire-item.cc
index 4edaa964fadae4a74d69d1fa0ed00809dced0688..6227888b6a933e71f2ba0c539ed7e63ef7a034d6 100644 (file)
--- a/apt-pkg/acquire-item.cc
+++ b/apt-pkg/acquire-item.cc
@@ -1,6 +1,6 @@
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/

-// $Id: acquire-item.cc,v 1.16 1998/12/11 06:01:23 jgg Exp $
+// $Id: acquire-item.cc,v 1.46 2003/02/02 22:19:17 jgg Exp $

 /* ######################################################################
 
    Acquire Item - Item to acquire
 /* ######################################################################
 
    Acquire Item - Item to acquire


@@ -18,22 +18,28 @@
 #endif
 #include <apt-pkg/acquire-item.h>
 #include <apt-pkg/configuration.h>
 #endif
 #include <apt-pkg/acquire-item.h>
 #include <apt-pkg/configuration.h>

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

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

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

 
 

+#include <apti18n.h>
+    

 #include <sys/stat.h>
 #include <unistd.h>
 #include <errno.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <errno.h>

-#include <string.h>
+#include <string>

 #include <stdio.h>
                                                                        /*}}}*/
 
 #include <stdio.h>
                                                                        /*}}}*/
 

+using std::string;
+

 // Acquire::Item::Item - Constructor                                   /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 pkgAcquire::Item::Item(pkgAcquire *Owner) : Owner(Owner), FileSize(0),
 // Acquire::Item::Item - Constructor                                   /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 pkgAcquire::Item::Item(pkgAcquire *Owner) : Owner(Owner), FileSize(0),

-                       Mode(0), ID(0), Complete(false), Local(false), 
-                       QueueCounter(0)
+                       PartialSize(0), Mode(0), ID(0), Complete(false), 
+                       Local(false), QueueCounter(0)

 {
    Owner->Add(this);
    Status = StatIdle;
 {
    Owner->Add(this);
    Status = StatIdle;


@@ -51,31 +57,33 @@ pkgAcquire::Item::~Item()
 // ---------------------------------------------------------------------
 /* We return to an idle state if there are still other queues that could
    fetch this object */
 // ---------------------------------------------------------------------
 /* We return to an idle state if there are still other queues that could
    fetch this object */

-void pkgAcquire::Item::Failed(string Message)
+void pkgAcquire::Item::Failed(string Message,pkgAcquire::MethodConfig *Cnf)

 {
    Status = StatIdle;
 {
    Status = StatIdle;

+   ErrorText = LookupTag(Message,"Message");

    if (QueueCounter <= 1)
    {
       /* This indicates that the file is not available right now but might
    if (QueueCounter <= 1)
    {
       /* This indicates that the file is not available right now but might

-         be sometime later. If we do a retry cycle then this should be 
-        retried */
-      if (StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
+         be sometime later. If we do a retry cycle then this should be
+        retried [CDROMs] */
+      if (Cnf->LocalOnly == true &&
+         StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)

       {
         Status = StatIdle;
       {
         Status = StatIdle;

-        Owner->Dequeue(this);
+        Dequeue();

         return;
       }
       
         return;
       }
       

-      ErrorText = LookupTag(Message,"Message");

       Status = StatError;
       Status = StatError;

-      Owner->Dequeue(this);
+      Dequeue();

    }   
 }
                                                                        /*}}}*/
 // Acquire::Item::Start - Item has begun to download                   /*{{{*/
 // ---------------------------------------------------------------------
    }   
 }
                                                                        /*}}}*/
 // Acquire::Item::Start - Item has begun to download                   /*{{{*/
 // ---------------------------------------------------------------------

-/* */
-void pkgAcquire::Item::Start(string Message,unsigned long Size)
+/* Stash status and the file size. Note that setting Complete means 
+   sub-phases of the acquire process such as decompresion are operating */
+void pkgAcquire::Item::Start(string /*Message*/,unsigned long Size)

 {
    Status = StatFetching;
    if (FileSize == 0 && Complete == false)
 {
    Status = StatFetching;
    if (FileSize == 0 && Complete == false)


@@ -85,7 +93,8 @@ void pkgAcquire::Item::Start(string Message,unsigned long Size)
 // Acquire::Item::Done - Item downloaded OK                            /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // Acquire::Item::Done - Item downloaded OK                            /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-void pkgAcquire::Item::Done(string Message,unsigned long Size,string)
+void pkgAcquire::Item::Done(string Message,unsigned long Size,string,
+                           pkgAcquire::MethodConfig *Cnf)

 {
    // We just downloaded something..
    string FileName = LookupTag(Message,"Filename");
 {
    // We just downloaded something..
    string FileName = LookupTag(Message,"Filename");


@@ -94,6 +103,9 @@ void pkgAcquire::Item::Done(string Message,unsigned long Size,string)
       if (Owner->Log != 0)
         Owner->Log->Fetched(Size,atoi(LookupTag(Message,"Resume-Point","0").c_str()));
    }
       if (Owner->Log != 0)
         Owner->Log->Fetched(Size,atoi(LookupTag(Message,"Resume-Point","0").c_str()));
    }

+
+   if (FileSize == 0)
+      FileSize= Size;

    
    Status = StatDone;
    ErrorText = string();
    
    Status = StatDone;
    ErrorText = string();


@@ -109,42 +121,38 @@ void pkgAcquire::Item::Rename(string From,string To)
    if (rename(From.c_str(),To.c_str()) != 0)
    {
       char S[300];
    if (rename(From.c_str(),To.c_str()) != 0)
    {
       char S[300];

-      sprintf(S,"rename failed, %s (%s -> %s).",strerror(errno),
+      snprintf(S,sizeof(S),_("rename failed, %s (%s -> %s)."),strerror(errno),

              From.c_str(),To.c_str());
       Status = StatError;
       ErrorText = S;
              From.c_str(),To.c_str());
       Status = StatError;
       ErrorText = S;

-   }      
+   }   

 }
                                                                        /*}}}*/
 
 // AcqIndex::AcqIndex - Constructor                                    /*{{{*/
 // ---------------------------------------------------------------------
 /* The package file is added to the queue and a second class is 
 }
                                                                        /*}}}*/
 
 // AcqIndex::AcqIndex - Constructor                                    /*{{{*/
 // ---------------------------------------------------------------------
 /* The package file is added to the queue and a second class is 

-   instantiated to fetch the revision file */
-pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner,const pkgSourceList::Item *Location) :
-             Item(Owner), Location(Location)
+   instantiated to fetch the revision file */   
+pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner,
+                        string URI,string URIDesc,string ShortDesc) :
+                      Item(Owner), RealURI(URI)

 {
    Decompression = false;
    Erase = false;
    
    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 {
    Decompression = false;
    Erase = false;
    
    DestFile = _config->FindDir("Dir::State::lists") + "partial/";

-   DestFile += URItoFileName(Location->PackagesURI());
-
-   // Create the item 
-   Desc.URI = Location->PackagesURI() + ".gz";
-   Desc.Description = Location->PackagesInfo();
-   Desc.Owner = this;
+   DestFile += URItoFileName(URI);

 
 

-   // Set the short description to the archive component
-   if (Location->Dist[Location->Dist.size() - 1] == '/')
-      Desc.ShortDesc = Location->Dist;
+   // Create the item
+   if(FileExists("/usr/bin/bzip2"))
+      Desc.URI = URI + ".bz2"; 

    else
    else

-      Desc.ShortDesc = Location->Dist + '/' + Location->Section;  
+      Desc.URI = URI + ".gz"; 
+   Desc.Description = URIDesc;
+   Desc.Owner = this;
+   Desc.ShortDesc = ShortDesc;

       
    QueueURI(Desc);
       
    QueueURI(Desc);

-   
-   // Create the Release fetch class
-   new pkgAcqIndexRel(Owner,Location);

 }
                                                                        /*}}}*/
 // AcqIndex::Custom600Headers - Insert custom request headers          /*{{{*/
 }
                                                                        /*}}}*/
 // AcqIndex::Custom600Headers - Insert custom request headers          /*{{{*/


@@ -153,7 +161,7 @@ pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner,const pkgSourceList::Item *Location)
 string pkgAcqIndex::Custom600Headers()
 {
    string Final = _config->FindDir("Dir::State::lists");
 string pkgAcqIndex::Custom600Headers()
 {
    string Final = _config->FindDir("Dir::State::lists");

-   Final += URItoFileName(Location->PackagesURI());
+   Final += URItoFileName(RealURI);

    
    struct stat Buf;
    if (stat(Final.c_str(),&Buf) != 0)
    
    struct stat Buf;
    if (stat(Final.c_str(),&Buf) != 0)


@@ -162,6 +170,21 @@ string pkgAcqIndex::Custom600Headers()
    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 }
                                                                        /*}}}*/
    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 }
                                                                        /*}}}*/

+
+void pkgAcqIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
+{
+   // no .bz2 found, retry with .gz
+   if(Desc.URI.substr(Desc.URI.size()-3,Desc.URI.size()-1) == "bz2") {
+      Desc.URI = Desc.URI.substr(0,Desc.URI.size()-3) + "gz"; 
+      QueueURI(Desc);
+      return;
+   }
+
+   
+   Item::Failed(Message,Cnf);
+}
+
+

 // AcqIndex::Done - Finished a fetch                                   /*{{{*/
 // ---------------------------------------------------------------------
 /* This goes through a number of states.. On the initial fetch the
 // AcqIndex::Done - Finished a fetch                                   /*{{{*/
 // ---------------------------------------------------------------------
 /* This goes through a number of states.. On the initial fetch the


@@ -169,21 +192,23 @@ string pkgAcqIndex::Custom600Headers()
    to the uncompressed version of the file. If this is so the file
    is copied into the partial directory. In all other cases the file
    is decompressed with a gzip uri. */
    to the uncompressed version of the file. If this is so the file
    is copied into the partial directory. In all other cases the file
    is decompressed with a gzip uri. */

-void pkgAcqIndex::Done(string Message,unsigned long Size,string MD5)
+void pkgAcqIndex::Done(string Message,unsigned long Size,string MD5,
+                      pkgAcquire::MethodConfig *Cfg)

 {
 {

-   Item::Done(Message,Size,MD5);
+   Item::Done(Message,Size,MD5,Cfg);

 
    if (Decompression == true)
    {
       // Done, move it into position
       string FinalFile = _config->FindDir("Dir::State::lists");
 
    if (Decompression == true)
    {
       // Done, move it into position
       string FinalFile = _config->FindDir("Dir::State::lists");

-      FinalFile += URItoFileName(Location->PackagesURI());
+      FinalFile += URItoFileName(RealURI);

       Rename(DestFile,FinalFile);
       Rename(DestFile,FinalFile);

+      chmod(FinalFile.c_str(),0644);

       
       /* We restore the original name to DestFile so that the clean operation
          will work OK */
       DestFile = _config->FindDir("Dir::State::lists") + "partial/";
       
       /* We restore the original name to DestFile so that the clean operation
          will work OK */
       DestFile = _config->FindDir("Dir::State::lists") + "partial/";

-      DestFile += URItoFileName(Location->PackagesURI());
+      DestFile += URItoFileName(RealURI);

       
       // Remove the compressed version.
       if (Erase == true)
       
       // Remove the compressed version.
       if (Erase == true)


@@ -227,19 +252,22 @@ void pkgAcqIndex::Done(string Message,unsigned long Size,string MD5)
    else
       Local = true;
    
    else
       Local = true;
    

+   string compExt = Desc.URI.substr(Desc.URI.size()-3,Desc.URI.size()-1);
+   char *decompProg;
+   if(compExt == "bz2") 
+      decompProg = "bzip2";
+   else if(compExt == ".gz") 
+      decompProg = "gzip";
+   else {
+      _error->Error("Unsupported extension: %s", compExt.c_str());
+      return;
+   }
+

    Decompression = true;
    DestFile += ".decomp";
    Decompression = true;
    DestFile += ".decomp";

-   Desc.URI = "gzip:" + FileName,Location->PackagesInfo();
+   Desc.URI = string(decompProg) + ":" + FileName;

    QueueURI(Desc);
    QueueURI(Desc);

-   Mode = "gzip";
-}
-                                                                       /*}}}*/
-// AcqIndex::Describe - Describe the Item                              /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-string pkgAcqIndex::Describe()
-{
-   return Location->PackagesURI();
+   Mode = decompProg;

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


@@ -247,23 +275,18 @@ string pkgAcqIndex::Describe()
 // ---------------------------------------------------------------------
 /* The Release file is added to the queue */
 pkgAcqIndexRel::pkgAcqIndexRel(pkgAcquire *Owner,
 // ---------------------------------------------------------------------
 /* The Release file is added to the queue */
 pkgAcqIndexRel::pkgAcqIndexRel(pkgAcquire *Owner,

-                              const pkgSourceList::Item *Location) :
-                Item(Owner), Location(Location)
+                           string URI,string URIDesc,string ShortDesc) :
+                      Item(Owner), RealURI(URI)

 {
    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 {
    DestFile = _config->FindDir("Dir::State::lists") + "partial/";

-   DestFile += URItoFileName(Location->ReleaseURI());
+   DestFile += URItoFileName(URI);

    
    // Create the item
    
    // Create the item

-   Desc.URI = Location->ReleaseURI();
-   Desc.Description = Location->ReleaseInfo();
+   Desc.URI = URI;
+   Desc.Description = URIDesc;
+   Desc.ShortDesc = ShortDesc;

    Desc.Owner = this;
 
    Desc.Owner = this;
 

-   // Set the short description to the archive component
-   if (Location->Dist[Location->Dist.size() - 1] == '/')
-      Desc.ShortDesc = Location->Dist;
-   else
-      Desc.ShortDesc = Location->Dist + '/' + Location->Section;  
-      

    QueueURI(Desc);
 }
                                                                        /*}}}*/
    QueueURI(Desc);
 }
                                                                        /*}}}*/


@@ -273,7 +296,7 @@ pkgAcqIndexRel::pkgAcqIndexRel(pkgAcquire *Owner,
 string pkgAcqIndexRel::Custom600Headers()
 {
    string Final = _config->FindDir("Dir::State::lists");
 string pkgAcqIndexRel::Custom600Headers()
 {
    string Final = _config->FindDir("Dir::State::lists");

-   Final += URItoFileName(Location->ReleaseURI());
+   Final += URItoFileName(RealURI);

    
    struct stat Buf;
    if (stat(Final.c_str(),&Buf) != 0)
    
    struct stat Buf;
    if (stat(Final.c_str(),&Buf) != 0)


@@ -287,9 +310,10 @@ string pkgAcqIndexRel::Custom600Headers()
 /* The release file was not placed into the download directory then
    a copy URI is generated and it is copied there otherwise the file
    in the partial directory is moved into .. and the URI is finished. */
 /* The release file was not placed into the download directory then
    a copy URI is generated and it is copied there otherwise the file
    in the partial directory is moved into .. and the URI is finished. */

-void pkgAcqIndexRel::Done(string Message,unsigned long Size,string MD5)
+void pkgAcqIndexRel::Done(string Message,unsigned long Size,string MD5,
+                         pkgAcquire::MethodConfig *Cfg)

 {
 {

-   Item::Done(Message,Size,MD5);
+   Item::Done(Message,Size,MD5,Cfg);

 
    string FileName = LookupTag(Message,"Filename");
    if (FileName.empty() == true)
 
    string FileName = LookupTag(Message,"Filename");
    if (FileName.empty() == true)


@@ -316,40 +340,92 @@ void pkgAcqIndexRel::Done(string Message,unsigned long Size,string MD5)
    
    // Done, move it into position
    string FinalFile = _config->FindDir("Dir::State::lists");
    
    // Done, move it into position
    string FinalFile = _config->FindDir("Dir::State::lists");

-   FinalFile += URItoFileName(Location->ReleaseURI());
+   FinalFile += URItoFileName(RealURI);

    Rename(DestFile,FinalFile);
    Rename(DestFile,FinalFile);

+   
+   chmod(FinalFile.c_str(),0644);

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

-// AcqIndexRel::Describe - Describe the Item                           /*{{{*/
+// AcqIndexRel::Failed - Silence failure messages for missing rel files        /*{{{*/

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

-string pkgAcqIndexRel::Describe()
+void pkgAcqIndexRel::Failed(string Message,pkgAcquire::MethodConfig *Cnf)

 {
 {

-   return Location->ReleaseURI();
+   if (Cnf->LocalOnly == true || 
+       StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)
+   {      
+      // Ignore this
+      Status = StatDone;
+      Complete = false;
+      Dequeue();
+      return;
+   }
+   
+   Item::Failed(Message,Cnf);

 }
                                                                        /*}}}*/
 
 // AcqArchive::AcqArchive - Constructor                                        /*{{{*/
 // ---------------------------------------------------------------------
 }
                                                                        /*}}}*/
 
 // AcqArchive::AcqArchive - Constructor                                        /*{{{*/
 // ---------------------------------------------------------------------

-/* */
+/* This just sets up the initial fetch environment and queues the first
+   possibilitiy */

 pkgAcqArchive::pkgAcqArchive(pkgAcquire *Owner,pkgSourceList *Sources,
                             pkgRecords *Recs,pkgCache::VerIterator const &Version,
                             string &StoreFilename) :
                Item(Owner), Version(Version), Sources(Sources), Recs(Recs), 
                StoreFilename(StoreFilename), Vf(Version.FileList())
 {
 pkgAcqArchive::pkgAcqArchive(pkgAcquire *Owner,pkgSourceList *Sources,
                             pkgRecords *Recs,pkgCache::VerIterator const &Version,
                             string &StoreFilename) :
                Item(Owner), Version(Version), Sources(Sources), Recs(Recs), 
                StoreFilename(StoreFilename), Vf(Version.FileList())
 {

+   Retries = _config->FindI("Acquire::Retries",0);
+
+   if (Version.Arch() == 0)
+   {
+      _error->Error(_("I wasn't able to locate a file for the %s package. "
+                     "This might mean you need to manually fix this package. "
+                     "(due to missing arch)"),
+                   Version.ParentPkg().Name());
+      return;
+   }
+   
+   /* We need to find a filename to determine the extension. We make the
+      assumption here that all the available sources for this version share
+      the same extension.. */
+   // Skip not source sources, they do not have file fields.
+   for (; Vf.end() == false; Vf++)
+   {
+      if ((Vf.File()->Flags & pkgCache::Flag::NotSource) != 0)
+        continue;
+      break;
+   }
+   
+   // Does not really matter here.. we are going to fail out below
+   if (Vf.end() != true)
+   {     
+      // If this fails to get a file name we will bomb out below.
+      pkgRecords::Parser &Parse = Recs->Lookup(Vf);
+      if (_error->PendingError() == true)
+        return;
+            
+      // Generate the final file name as: package_version_arch.foo
+      StoreFilename = QuoteString(Version.ParentPkg().Name(),"_:") + '_' +
+                     QuoteString(Version.VerStr(),"_:") + '_' +
+                     QuoteString(Version.Arch(),"_:.") + 
+                     "." + flExtension(Parse.FileName());
+   }
+      

    // Select a source
    if (QueueNext() == false && _error->PendingError() == false)
    // Select a source
    if (QueueNext() == false && _error->PendingError() == false)

-      _error->Error("I wasn't able to locate file for the %s package. "
-                   "This might mean you need to manually fix this package.",
+      _error->Error(_("I wasn't able to locate file for the %s package. "
+                   "This might mean you need to manually fix this package."),

                    Version.ParentPkg().Name());
 }
                                                                        /*}}}*/
 // AcqArchive::QueueNext - Queue the next file source                  /*{{{*/
 // ---------------------------------------------------------------------
                    Version.ParentPkg().Name());
 }
                                                                        /*}}}*/
 // AcqArchive::QueueNext - Queue the next file source                  /*{{{*/
 // ---------------------------------------------------------------------

-/* This queues the next available file version for download. */
+/* This queues the next available file version for download. It checks if
+   the archive is already available in the cache and stashs the MD5 for
+   checking later. */

 bool pkgAcqArchive::QueueNext()
 bool pkgAcqArchive::QueueNext()

-{
+{   

    for (; Vf.end() == false; Vf++)
    {
       // Ignore not source sources
    for (; Vf.end() == false; Vf++)
    {
       // Ignore not source sources


@@ -357,28 +433,23 @@ bool pkgAcqArchive::QueueNext()
         continue;
 
       // Try to cross match against the source list
         continue;
 
       // Try to cross match against the source list

-      string PkgFile = flNotDir(Vf.File().FileName());
-      pkgSourceList::const_iterator Location;
-      for (Location = Sources->begin(); Location != Sources->end(); Location++)
-        if (PkgFile == URItoFileName(Location->PackagesURI()))
-           break;
-
-      if (Location == Sources->end())
-        continue;
+      pkgIndexFile *Index;
+      if (Sources->FindIndex(Vf.File(),Index) == false)
+           continue;

       
       // Grab the text package record
       pkgRecords::Parser &Parse = Recs->Lookup(Vf);
       if (_error->PendingError() == true)
         return false;
       
       
       // Grab the text package record
       pkgRecords::Parser &Parse = Recs->Lookup(Vf);
       if (_error->PendingError() == true)
         return false;
       

-      PkgFile = Parse.FileName();
+      string PkgFile = Parse.FileName();

       MD5 = Parse.MD5Hash();
       if (PkgFile.empty() == true)
       MD5 = Parse.MD5Hash();
       if (PkgFile.empty() == true)

-        return _error->Error("The package index files are corrupted. No Filename: "
-                             "field for package %s."
-                             ,Version.ParentPkg().Name());
+        return _error->Error(_("The package index files are corrupted. No Filename: "
+                             "field for package %s."),
+                             Version.ParentPkg().Name());

 
 

-      // See if we already have the file.
+      // See if we already have the file. (Legacy filenames)

       FileSize = Version->Size;
       string FinalFile = _config->FindDir("Dir::Cache::Archives") + flNotDir(PkgFile);
       struct stat Buf;
       FileSize = Version->Size;
       string FinalFile = _config->FindDir("Dir::Cache::Archives") + flNotDir(PkgFile);
       struct stat Buf;


@@ -394,16 +465,46 @@ bool pkgAcqArchive::QueueNext()
            return true;
         }
         
            return true;
         }
         

+        /* Hmm, we have a file and its size does not match, this means it is
+           an old style mismatched arch */
+        unlink(FinalFile.c_str());
+      }
+
+      // Check it again using the new style output filenames
+      FinalFile = _config->FindDir("Dir::Cache::Archives") + flNotDir(StoreFilename);
+      if (stat(FinalFile.c_str(),&Buf) == 0)
+      {
+        // Make sure the size matches
+        if ((unsigned)Buf.st_size == Version->Size)
+        {
+           Complete = true;
+           Local = true;
+           Status = StatDone;
+           StoreFilename = DestFile = FinalFile;
+           return true;
+        }
+        

         /* Hmm, we have a file and its size does not match, this shouldnt
            happen.. */
         unlink(FinalFile.c_str());
       }
         /* Hmm, we have a file and its size does not match, this shouldnt
            happen.. */
         unlink(FinalFile.c_str());
       }

+
+      DestFile = _config->FindDir("Dir::Cache::Archives") + "partial/" + flNotDir(StoreFilename);

       
       

-      DestFile = _config->FindDir("Dir::Cache::Archives") + "partial/" + flNotDir(PkgFile);
+      // Check the destination file
+      if (stat(DestFile.c_str(),&Buf) == 0)
+      {
+        // Hmm, the partial file is too big, erase it
+        if ((unsigned)Buf.st_size > Version->Size)
+           unlink(DestFile.c_str());
+        else
+           PartialSize = Buf.st_size;
+      }

       
       // Create the item
       
       // Create the item

-      Desc.URI = Location->ArchiveURI(PkgFile);
-      Desc.Description = Location->ArchiveInfo(Version);
+      Local = false;
+      Desc.URI = Index->ArchiveURI(PkgFile);
+      Desc.Description = Index->ArchiveInfo(Version);

       Desc.Owner = this;
       Desc.ShortDesc = Version.ParentPkg().Name();
       QueueURI(Desc);
       Desc.Owner = this;
       Desc.ShortDesc = Version.ParentPkg().Name();
       QueueURI(Desc);


@@ -417,14 +518,16 @@ bool pkgAcqArchive::QueueNext()
 // AcqArchive::Done - Finished fetching                                        /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // AcqArchive::Done - Finished fetching                                        /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-void pkgAcqArchive::Done(string Message,unsigned long Size,string Md5Hash)
+void pkgAcqArchive::Done(string Message,unsigned long Size,string Md5Hash,
+                        pkgAcquire::MethodConfig *Cfg)

 {
 {

-   Item::Done(Message,Size,MD5);
+   Item::Done(Message,Size,Md5Hash,Cfg);

    
    // Check the size
    if (Size != Version->Size)
    {
    
    // Check the size
    if (Size != Version->Size)
    {

-      _error->Error("Size mismatch for package %s",Version.ParentPkg().Name());
+      Status = StatError;
+      ErrorText = _("Size mismatch");

       return;
    }
    
       return;
    }
    


@@ -433,7 +536,9 @@ void pkgAcqArchive::Done(string Message,unsigned long Size,string Md5Hash)
    {
       if (Md5Hash != MD5)
       {
    {
       if (Md5Hash != MD5)
       {

-        _error->Error("MD5Sum mismatch for package %s",Version.ParentPkg().Name());
+        Status = StatError;
+        ErrorText = _("MD5Sum mismatch");
+        Rename(DestFile,DestFile + ".FAILED");

         return;
       }
    }
         return;
       }
    }


@@ -459,18 +564,178 @@ void pkgAcqArchive::Done(string Message,unsigned long Size,string Md5Hash)
    
    // Done, move it into position
    string FinalFile = _config->FindDir("Dir::Cache::Archives");
    
    // Done, move it into position
    string FinalFile = _config->FindDir("Dir::Cache::Archives");

-   FinalFile += flNotDir(DestFile);
+   FinalFile += flNotDir(StoreFilename);

    Rename(DestFile,FinalFile);
    
    StoreFilename = DestFile = FinalFile;
    Complete = true;
 }
                                                                        /*}}}*/
    Rename(DestFile,FinalFile);
    
    StoreFilename = DestFile = FinalFile;
    Complete = true;
 }
                                                                        /*}}}*/

-// AcqArchive::Describe - Describe the Item                            /*{{{*/
+// AcqArchive::Failed - Failure handler                                        /*{{{*/
+// ---------------------------------------------------------------------
+/* Here we try other sources */
+void pkgAcqArchive::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
+{
+   ErrorText = LookupTag(Message,"Message");
+   
+   /* We don't really want to retry on failed media swaps, this prevents 
+      that. An interesting observation is that permanent failures are not
+      recorded. */
+   if (Cnf->Removable == true && 
+       StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
+   {
+      // Vf = Version.FileList();
+      while (Vf.end() == false) Vf++;
+      StoreFilename = string();
+      Item::Failed(Message,Cnf);
+      return;
+   }
+   
+   if (QueueNext() == false)
+   {
+      // This is the retry counter
+      if (Retries != 0 &&
+         Cnf->LocalOnly == false &&
+         StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
+      {
+        Retries--;
+        Vf = Version.FileList();
+        if (QueueNext() == true)
+           return;
+      }
+      
+      StoreFilename = string();
+      Item::Failed(Message,Cnf);
+   }
+}
+                                                                       /*}}}*/
+// AcqArchive::Finished - Fetching has finished, tidy up               /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+void pkgAcqArchive::Finished()
+{
+   if (Status == pkgAcquire::Item::StatDone &&
+       Complete == true)
+      return;
+   StoreFilename = string();
+}
+                                                                       /*}}}*/
+
+// AcqFile::pkgAcqFile - Constructor                                   /*{{{*/
+// ---------------------------------------------------------------------
+/* The file is added to the queue */
+pkgAcqFile::pkgAcqFile(pkgAcquire *Owner,string URI,string MD5,
+                      unsigned long Size,string Dsc,string ShortDesc) :
+                       Item(Owner), Md5Hash(MD5)
+{
+   Retries = _config->FindI("Acquire::Retries",0);
+   
+   DestFile = flNotDir(URI);
+   
+   // Create the item
+   Desc.URI = URI;
+   Desc.Description = Dsc;
+   Desc.Owner = this;
+
+   // Set the short description to the archive component
+   Desc.ShortDesc = ShortDesc;
+      
+   // Get the transfer sizes
+   FileSize = Size;
+   struct stat Buf;
+   if (stat(DestFile.c_str(),&Buf) == 0)
+   {
+      // Hmm, the partial file is too big, erase it
+      if ((unsigned)Buf.st_size > Size)
+        unlink(DestFile.c_str());
+      else
+        PartialSize = Buf.st_size;
+   }
+   
+   QueueURI(Desc);
+}
+                                                                       /*}}}*/
+// AcqFile::Done - Item downloaded OK                                  /*{{{*/

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

-string pkgAcqArchive::Describe()
+void pkgAcqFile::Done(string Message,unsigned long Size,string MD5,
+                     pkgAcquire::MethodConfig *Cnf)
+{
+   // Check the md5
+   if (Md5Hash.empty() == false && MD5.empty() == false)
+   {
+      if (Md5Hash != MD5)
+      {
+        Status = StatError;
+        ErrorText = "MD5Sum mismatch";
+        Rename(DestFile,DestFile + ".FAILED");
+        return;
+      }
+   }
+   
+   Item::Done(Message,Size,MD5,Cnf);
+
+   string FileName = LookupTag(Message,"Filename");
+   if (FileName.empty() == true)
+   {
+      Status = StatError;
+      ErrorText = "Method gave a blank filename";
+      return;
+   }
+
+   Complete = true;
+   
+   // The files timestamp matches
+   if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
+      return;
+   
+   // We have to copy it into place
+   if (FileName != DestFile)
+   {
+      Local = true;
+      if (_config->FindB("Acquire::Source-Symlinks",true) == false ||
+         Cnf->Removable == true)
+      {
+        Desc.URI = "copy:" + FileName;
+        QueueURI(Desc);
+        return;
+      }
+      
+      // Erase the file if it is a symlink so we can overwrite it
+      struct stat St;
+      if (lstat(DestFile.c_str(),&St) == 0)
+      {
+        if (S_ISLNK(St.st_mode) != 0)
+           unlink(DestFile.c_str());
+      }
+      
+      // Symlink the file
+      if (symlink(FileName.c_str(),DestFile.c_str()) != 0)
+      {
+        ErrorText = "Link to " + DestFile + " failure ";
+        Status = StatError;
+        Complete = false;
+      }      
+   }
+}
+                                                                       /*}}}*/
+// AcqFile::Failed - Failure handler                                   /*{{{*/
+// ---------------------------------------------------------------------
+/* Here we try other sources */
+void pkgAcqFile::Failed(string Message,pkgAcquire::MethodConfig *Cnf)

 {
 {

-   return Desc.URI;
+   ErrorText = LookupTag(Message,"Message");
+   
+   // This is the retry counter
+   if (Retries != 0 &&
+       Cnf->LocalOnly == false &&
+       StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
+   {
+      Retries--;
+      QueueURI(Desc);
+      return;
+   }
+   
+   Item::Failed(Message,Cnf);

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