apt-inst/deb/debfile.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: debfile.cc,v 1.3.2.1 2004/01/16 18:58:50 mdz Exp $
   4 /* ######################################################################
   5
   6    Debian Archive File (.deb)
   7
   8    .DEB archives are AR files containing two tars and an empty marker
   9    member called 'debian-binary'. The two tars contain the meta data and
  10    the actual archive contents. Thus this class is a very simple wrapper
  11    around ar/tar to simply extract the right tar files.
  12
  13    It also uses the deb package list parser to parse the control file
  14    into the cache.
  15
  16    ##################################################################### */
  17                                                                         /*}}}*/
  18 // Include Files                                                        /*{{{*/
  19 #include<config.h>
  20
  21 #include <apt-pkg/debfile.h>
  22 #include <apt-pkg/extracttar.h>
  23 #include <apt-pkg/error.h>
  24 #include <apt-pkg/aptconfiguration.h>
  25 #include <apt-pkg/arfile.h>
  26 #include <apt-pkg/dirstream.h>
  27 #include <apt-pkg/fileutl.h>
  28 #include <apt-pkg/tagfile.h>
  29
  30 #include <string.h>
  31 #include <string>
  32 #include <vector>
  33 #include <sys/stat.h>
  34
  35 #include <apti18n.h>
  36                                                                         /*}}}*/
  37
  38 // DebFile::debDebFile - Constructor                                    /*{{{*/
  39 // ---------------------------------------------------------------------
  40 /* Open the AR file and check for consistency */
  41 debDebFile::debDebFile(FileFd &File) : File(File), AR(File)
  42 {
  43    if (_error->PendingError() == true)
  44       return;
  45
  46    if (!CheckMember("debian-binary")) {
  47       _error->Error(_("This is not a valid DEB archive, missing '%s' member"), "debian-binary");
  48       return;
  49    }
  50
  51    if (!CheckMember("control.tar") &&
  52        !CheckMember("control.tar.gz") &&
  53        !CheckMember("control.tar.xz")) {
  54       _error->Error(_("This is not a valid DEB archive, missing '%s' member"), "control.tar");
  55       return;
  56    }
  57
  58    if (!CheckMember("data.tar") &&
  59        !CheckMember("data.tar.gz") &&
  60        !CheckMember("data.tar.bz2") &&
  61        !CheckMember("data.tar.lzma") &&
  62        !CheckMember("data.tar.xz")) {
  63       _error->Error(_("This is not a valid DEB archive, missing '%s' member"), "data.tar");
  64       return;
  65    }
  66 }
  67                                                                         /*}}}*/
  68 // DebFile::CheckMember - Check if a named member is in the archive     /*{{{*/
  69 // ---------------------------------------------------------------------
  70 /* This is used to check for a correct deb and to give nicer error messages
  71    for people playing around. */
  72 bool debDebFile::CheckMember(const char *Name)
  73 {
  74    if (AR.FindMember(Name) == 0)
  75       return false;
  76    return true;
  77 }
  78                                                                         /*}}}*/
  79 // DebFile::GotoMember - Jump to a Member                               /*{{{*/
  80 // ---------------------------------------------------------------------
  81 /* Jump in the file to the start of a named member and return the information
  82    about that member. The caller can then read from the file up to the
  83    returned size. Note, since this relies on the file position this is
  84    a destructive operation, it also changes the last returned Member
  85    structure - so don't nest them! */
  86 const ARArchive::Member *debDebFile::GotoMember(const char *Name)
  87 {
  88    // Get the archive member and positition the file
  89    const ARArchive::Member *Member = AR.FindMember(Name);
  90    if (Member == 0)
  91    {
  92       return 0;
  93    }
  94    if (File.Seek(Member->Start) == false)
  95       return 0;
  96
  97    return Member;
  98 }
  99                                                                         /*}}}*/
 100 // DebFile::ExtractTarMember - Extract the contents of a tar member     /*{{{*/
 101 // ---------------------------------------------------------------------
 102 /* Simple wrapper around tar.. */
 103 bool debDebFile::ExtractTarMember(pkgDirStream &Stream,const char *Name)
 104 {
 105    // Get the archive member
 106    const ARArchive::Member *Member = NULL;
 107    std::string Compressor;
 108
 109    std::vector<APT::Configuration::Compressor> compressor = APT::Configuration::getCompressors();
 110    for (std::vector<APT::Configuration::Compressor>::const_iterator c = compressor.begin();
 111         c != compressor.end(); ++c)
 112    {
 113       Member = AR.FindMember(std::string(Name).append(c->Extension).c_str());
 114       if (Member == NULL)
 115          continue;
 116       Compressor = c->Binary;
 117       break;
 118    }
 119
 120    if (Member == NULL)
 121       Member = AR.FindMember(std::string(Name).c_str());
 122
 123    if (Member == NULL)
 124    {
 125       std::string ext = std::string(Name) + ".{";
 126       for (std::vector<APT::Configuration::Compressor>::const_iterator c = compressor.begin();
 127            c != compressor.end(); ++c) {
 128          if (!c->Extension.empty())
 129             ext.append(c->Extension.substr(1));
 130       }
 131       ext.append("}");
 132       return _error->Error(_("Internal error, could not locate member %s"), ext.c_str());
 133    }
 134
 135    if (File.Seek(Member->Start) == false)
 136       return false;
 137
 138    // Prepare Tar
 139    ExtractTar Tar(File,Member->Size,Compressor);
 140    if (_error->PendingError() == true)
 141       return false;
 142    return Tar.Go(Stream);
 143 }
 144                                                                         /*}}}*/
 145 // DebFile::ExtractArchive - Extract the archive data itself            /*{{{*/
 146 // ---------------------------------------------------------------------
 147 /* Simple wrapper around DebFile::ExtractTarMember. */
 148 bool debDebFile::ExtractArchive(pkgDirStream &Stream)
 149 {
 150    return ExtractTarMember(Stream, "data.tar");
 151 }
 152                                                                         /*}}}*/
 153
 154 // DebFile::ControlExtract::DoItem - Control Tar Extraction             /*{{{*/
 155 // ---------------------------------------------------------------------
 156 /* This directory stream handler for the control tar handles extracting
 157    it into the temporary meta directory. It only extracts files, it does
 158    not create directories, links or anything else. */
 159 bool debDebFile::ControlExtract::DoItem(Item &Itm,int &Fd)
 160 {
 161    if (Itm.Type != Item::File)
 162       return true;
 163
 164    /* Cleanse the file name, prevent people from trying to unpack into
 165       absolute paths, .., etc */
 166    for (char *I = Itm.Name; *I != 0; I++)
 167       if (*I == '/')
 168          *I = '_';
 169
 170    /* Force the ownership to be root and ensure correct permissions,
 171       go-w, the rest are left untouched */
 172    Itm.UID = 0;
 173    Itm.GID = 0;
 174    Itm.Mode &= ~(S_IWGRP | S_IWOTH);
 175
 176    return pkgDirStream::DoItem(Itm,Fd);
 177 }
 178                                                                         /*}}}*/
 179
 180 // MemControlExtract::DoItem - Check if it is the control file          /*{{{*/
 181 // ---------------------------------------------------------------------
 182 /* This sets up to extract the control block member file into a memory
 183    block of just the right size. All other files go into the bit bucket. */
 184 bool debDebFile::MemControlExtract::DoItem(Item &Itm,int &Fd)
 185 {
 186    // At the control file, allocate buffer memory.
 187    if (Member == Itm.Name)
 188    {
 189       delete [] Control;
 190       Control = new char[Itm.Size+2];
 191       IsControl = true;
 192       Fd = -2; // Signal to pass to Process
 193       Length = Itm.Size;
 194    }
 195    else
 196       IsControl = false;
 197
 198    return true;
 199 }
 200                                                                         /*}}}*/
 201 // MemControlExtract::Process - Process extracting the control file     /*{{{*/
 202 // ---------------------------------------------------------------------
 203 /* Just memcopy the block from the tar extractor and put it in the right
 204    place in the pre-allocated memory block. */
 205 bool debDebFile::MemControlExtract::Process(Item &/*Itm*/,const unsigned char *Data,
 206                              unsigned long Size,unsigned long Pos)
 207 {
 208    memcpy(Control + Pos, Data,Size);
 209    return true;
 210 }
 211                                                                         /*}}}*/
 212 // MemControlExtract::Read - Read the control information from the deb  /*{{{*/
 213 // ---------------------------------------------------------------------
 214 /* This uses the internal tar extractor to fetch the control file, and then
 215    it parses it into a tag section parser. */
 216 bool debDebFile::MemControlExtract::Read(debDebFile &Deb)
 217 {
 218    if (Deb.ExtractTarMember(*this, "control.tar") == false)
 219       return false;
 220
 221    if (Control == 0)
 222       return true;
 223
 224    Control[Length] = '\n';
 225    Control[Length+1] = '\n';
 226    if (Section.Scan(Control,Length+2) == false)
 227       return _error->Error(_("Unparsable control file"));
 228    return true;
 229 }
 230                                                                         /*}}}*/
 231 // MemControlExtract::TakeControl - Parse a memory block                /*{{{*/
 232 // ---------------------------------------------------------------------
 233 /* The given memory block is loaded into the parser and parsed as a control
 234    record. */
 235 bool debDebFile::MemControlExtract::TakeControl(const void *Data,unsigned long Size)
 236 {
 237    delete [] Control;
 238    Control = new char[Size+2];
 239    Length = Size;
 240    memcpy(Control,Data,Size);
 241
 242    Control[Length] = '\n';
 243    Control[Length+1] = '\n';
 244    return Section.Scan(Control,Length+2);
 245 }
 246                                                                         /*}}}*/
 247