// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
-// $Id: extract.cc,v 1.3 2001/05/27 23:47:14 jgg Exp $
+// $Id: extract.cc,v 1.6.2.1 2004/01/16 18:58:50 mdz Exp $
/* ######################################################################
Archive Extraction Directory Stream
object is unpacked to '.dpkg.new' then the original is hardlinked to
'.dpkg.tmp' and finally the new object is renamed to overwrite the old
one. From an external perspective the file never ceased to exist.
- After the archive has been sucessfully unpacked the .dpkg.tmp files
+ After the archive has been successfully unpacked the .dpkg.tmp files
are erased. A failure causes all the .dpkg.tmp files to be restored.
Decisions about unpacking go like this:
[Note, this is reduced to only check if a file was expected to be
there]
- If the existing link/file is not a directory then it is replaced
- irregardless
+ regardless
- If the existing link/directory is being replaced by a directory then
absolutely nothing happens.
- If the existing link/directory is being replaced by a link then
##################################################################### */
/*}}}*/
// Include Files /*{{{*/
-#ifdef __GNUG__
-#pragma implementation "apt-pkg/extract.h"
-#endif
+#include<config.h>
+
#include <apt-pkg/extract.h>
#include <apt-pkg/error.h>
#include <apt-pkg/debversion.h>
+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/dirstream.h>
+#include <apt-pkg/filelist.h>
+#include <apt-pkg/mmap.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/cacheiterators.h>
+#include <string.h>
+#include <string>
#include <sys/stat.h>
#include <stdio.h>
-#include <unistd.h>
#include <errno.h>
#include <dirent.h>
-#include <iostream.h>
+#include <iostream>
+
+#include <apti18n.h>
/*}}}*/
+using namespace std;
static const char *TempExt = "dpkg-tmp";
//static const char *NewExt = "dpkg-new";
// Extract::DoItem - Handle a single item from the stream /*{{{*/
// ---------------------------------------------------------------------
/* This performs the setup for the extraction.. */
-bool pkgExtract::DoItem(Item &Itm,int &Fd)
+bool pkgExtract::DoItem(Item &Itm, int &/*Fd*/)
{
- char Temp[sizeof(FileName)];
-
/* Strip any leading/trailing /s from the filename, then copy it to the
temp buffer and re-apply the leading / We use a class variable
to store the new filename for use by the three extraction funcs */
for (; *I != 0 && End < FileName + sizeof(FileName); I++, End++)
*End = *I;
if (End + 20 >= FileName + sizeof(FileName))
- return _error->Error("The path %s is too long",Itm.Name);
+ return _error->Error(_("The path %s is too long"),Itm.Name);
for (; End > FileName && End[-1] == '/'; End--);
*End = 0;
Itm.Name = FileName;
which case this needs to be modified anyhow.. */
if ((RealNde->Flags & pkgFLCache::Node::Unpacked) ==
pkgFLCache::Node::Unpacked)
- return _error->Error("Unpacking %s more than once",Itm.Name);
+ return _error->Error(_("Unpacking %s more than once"),Itm.Name);
if (Nde.end() == true)
Nde = RealNde;
if ((Nde->Flags & pkgFLCache::Node::Diversion) != 0)
{
if (Itm.Type == Item::Directory)
- return _error->Error("The directory %s is diverted",Itm.Name);
+ return _error->Error(_("The directory %s is diverted"),Itm.Name);
/* A package overwriting a diversion target is just the same as
overwriting a normally owned file and is checked for below in
that is never, ever permitted */
pkgFLCache::DiverIterator Div = Nde.Diversion();
if (Div.DivertTo() == Nde)
- return _error->Error("The package is trying to write to the "
- "diversion target %s/%s",Nde.DirN(),Nde.File());
+ return _error->Error(_("The package is trying to write to the "
+ "diversion target %s/%s"),Nde.DirN(),Nde.File());
// See if it is us and we are following it in the right direction
if (Div->OwnerPkg != FLPkg.Offset() && Div.DivertFrom() == Nde)
End = FileName + snprintf(FileName,sizeof(FileName)-20,"%s/%s",
Nde.DirN(),Nde.File());
if (End <= FileName)
- return _error->Error("The diversion path is too long");
+ return _error->Error(_("The diversion path is too long"));
}
}
{
string Res = flNoLink(Itm.Name);
if (Res.length() > sizeof(FileName))
- return _error->Error("The path %s is too long",Res.c_str());
+ return _error->Error(_("The path %s is too long"),Res.c_str());
if (Debug == true)
clog << "Followed conf file from " << FileName << " to " << Res << endl;
Itm.Name = strcpy(FileName,Res.c_str());
{
// This is bad news.
if (errno != ENOENT)
- return _error->Errno("stat","Failed to stat %s",Itm.Name);
+ return _error->Errno("stat",_("Failed to stat %s"),Itm.Name);
// See if we can recover the backup file
if (Nde.end() == false)
{
+ char Temp[sizeof(FileName)];
snprintf(Temp,sizeof(Temp),"%s.%s",Itm.Name,TempExt);
if (rename(Temp,Itm.Name) != 0 && errno != ENOENT)
- return _error->Errno("rename","Failed to rename %s to %s",
+ return _error->Errno("rename",_("Failed to rename %s to %s"),
Temp,Itm.Name);
if (stat(Itm.Name,&LExisting) != 0)
{
if (errno != ENOENT)
- return _error->Errno("stat","Failed to stat %s",Itm.Name);
+ return _error->Errno("stat",_("Failed to stat %s"),Itm.Name);
}
else
EValid = true;
if (stat(Itm.Name,&Existing) != 0)
{
if (errno != ENOENT)
- return _error->Errno("stat","Failed to stat %s",Itm.Name);
+ return _error->Errno("stat",_("Failed to stat %s"),Itm.Name);
Existing = LExisting;
}
}
if (S_ISDIR(Existing.st_mode) != 0)
{
if (CheckDirReplace(Itm.Name) == false)
- return _error->Error("The directory %s is being replaced by a non-directory",Itm.Name);
+ return _error->Error(_("The directory %s is being replaced by a non-directory"),Itm.Name);
}
if (Debug == true)
clog << "Extract " << string(Itm.Name,End) << endl;
/* if (Count != 0)
- return _error->Error("Done");*/
+ return _error->Error(_("Done"));*/
return true;
}
// Extract::Finished - Sequence finished, erase the temp files /*{{{*/
// ---------------------------------------------------------------------
/* */
-bool pkgExtract::Finished()
+APT_CONST bool pkgExtract::Finished()
{
return true;
}
map_ptrloc *Last = &FLPkg->Files;
/* Loop over all files, restore those that have been unpacked from their
- dpkg-tmp entires */
+ dpkg-tmp entries */
while (Files.end() == false)
{
// Locate the hash bucket for the node and locate its group head
pkgFLCache::NodeIterator Nde(FLCache,FLCache.HashNode(Files));
for (; Nde.end() == false && Files->File != Nde->File; Nde++);
if (Nde.end() == true)
- return _error->Error("Failed to locate node in its hash bucket");
+ return _error->Error(_("Failed to locate node in its hash bucket"));
if (snprintf(FileName,sizeof(FileName)-20,"%s/%s",
Nde.DirN(),Nde.File()) <= 0)
- return _error->Error("The path is too long");
+ return _error->Error(_("The path is too long"));
// Deal with diversions
if ((Nde->Flags & pkgFLCache::Node::Diversion) != 0)
Nde = Div.DivertTo();
if (snprintf(FileName,sizeof(FileName)-20,"%s/%s",
Nde.DirN(),Nde.File()) <= 0)
- return _error->Error("The diversion path is too long");
+ return _error->Error(_("The diversion path is too long"));
}
}
pkgFLCache::NodeIterator TmpNde = Nde;
unsigned long DiverOwner = 0;
unsigned long FileGroup = Nde->File;
- const char *FirstOwner = 0;
for (; Nde.end() == false && FileGroup == Nde->File; Nde++)
{
if ((Nde->Flags & pkgFLCache::Node::Diversion) != 0)
if something has already been diverted by this diversion */
if (FPkg.Offset() == DiverOwner)
continue;
- FirstOwner = FPkg.Name();
-
+
// Now see if this package matches one in a replace depends
pkgCache::DepIterator Dep = Ver.DependsList();
bool Ok = false;
- for (; Dep.end() == false; Dep++)
+ for (; Dep.end() == false; ++Dep)
{
if (Dep->Type != pkgCache::Dep::Replaces)
continue;
pkgCache::PkgIterator Pkg = Dep.TargetPkg();
if (Pkg->CurrentVer == 0)
{
- _error->Warning("Overwrite package match with no version for %s",Pkg.Name());
+ _error->Warning(_("Overwrite package match with no version for %s"),Pkg.Name());
continue;
}
// Negative Hit
if (Ok == false)
- return _error->Error("File %s/%s overwrites the one in the package %s",
+ return _error->Error(_("File %s/%s overwrites the one in the package %s"),
Nde.DirN(),Nde.File(),FPkg.Name());
}
DIR *D = opendir(Dir.c_str());
if (D == 0)
- return _error->Errno("opendir","Unable to read %s",Dir.c_str());
+ return _error->Errno("opendir",_("Unable to read %s"),Dir.c_str());
string File;
for (struct dirent *Dent = readdir(D); Dent != 0; Dent = readdir(D))
if (lstat(File.c_str(),&St) != 0)
{
closedir(D);
- return _error->Errno("lstat","Unable to stat %s",File.c_str());
+ return _error->Errno("lstat",_("Unable to stat %s"),File.c_str());
}
// Recurse down directories
projects / apt.git / blobdiff