]> git.saurik.com Git - apt.git/blob - apt-inst/deb/debfile.cc
* merged from dpkg-log branch
[apt.git] / 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 <apt-pkg/debfile.h>
20 #include <apt-pkg/extracttar.h>
21 #include <apt-pkg/error.h>
22 #include <apt-pkg/deblistparser.h>
23
24 #include <sys/stat.h>
25 #include <unistd.h>
26 #include <apti18n.h>
27 /*}}}*/
28
29 // DebFile::debDebFile - Constructor /*{{{*/
30 // ---------------------------------------------------------------------
31 /* Open the AR file and check for consistency */
32 debDebFile::debDebFile(FileFd &File) : File(File), AR(File)
33 {
34 if (_error->PendingError() == true)
35 return;
36
37 if (!CheckMember("debian-binary")) {
38 _error->Error(_("This is not a valid DEB archive, missing '%s' member"), "debian-binary");
39 return;
40 }
41
42 if (!CheckMember("control.tar.gz")) {
43 _error->Error(_("This is not a valid DEB archive, missing '%s' member"), "control.tar.gz");
44 return;
45 }
46
47 if (!CheckMember("data.tar.gz") &&
48 !CheckMember("data.tar.bz2") &&
49 !CheckMember("data.tar.lzma")) {
50 _error->Error(_("This is not a valid DEB archive, it has no '%s', '%s' or '%s' member"), "data.tar.gz", "data.tar.bz2", "data.tar.lzma");
51 return;
52 }
53 }
54 /*}}}*/
55 // DebFile::CheckMember - Check if a named member is in the archive /*{{{*/
56 // ---------------------------------------------------------------------
57 /* This is used to check for a correct deb and to give nicer error messages
58 for people playing around. */
59 bool debDebFile::CheckMember(const char *Name)
60 {
61 if (AR.FindMember(Name) == 0)
62 return false;
63 return true;
64 }
65 /*}}}*/
66 // DebFile::GotoMember - Jump to a Member /*{{{*/
67 // ---------------------------------------------------------------------
68 /* Jump in the file to the start of a named member and return the information
69 about that member. The caller can then read from the file up to the
70 returned size. Note, since this relies on the file position this is
71 a destructive operation, it also changes the last returned Member
72 structure - so don't nest them! */
73 const ARArchive::Member *debDebFile::GotoMember(const char *Name)
74 {
75 // Get the archive member and positition the file
76 const ARArchive::Member *Member = AR.FindMember(Name);
77 if (Member == 0)
78 {
79 return 0;
80 }
81 if (File.Seek(Member->Start) == false)
82 return 0;
83
84 return Member;
85 }
86 /*}}}*/
87 // DebFile::ExtractControl - Extract Control information /*{{{*/
88 // ---------------------------------------------------------------------
89 /* Extract the control information into the Database's temporary
90 directory. */
91 bool debDebFile::ExtractControl(pkgDataBase &DB)
92 {
93 // Get the archive member and positition the file
94 const ARArchive::Member *Member = GotoMember("control.tar.gz");
95 if (Member == 0)
96 return false;
97
98 // Prepare Tar
99 ControlExtract Extract;
100 ExtractTar Tar(File,Member->Size,"gzip");
101 if (_error->PendingError() == true)
102 return false;
103
104 // Get into the temporary directory
105 string Cwd = SafeGetCWD();
106 string Tmp;
107 if (DB.GetMetaTmp(Tmp) == false)
108 return false;
109 if (chdir(Tmp.c_str()) != 0)
110 return _error->Errno("chdir",_("Couldn't change to %s"),Tmp.c_str());
111
112 // Do extraction
113 if (Tar.Go(Extract) == false)
114 return false;
115
116 // Switch out of the tmp directory.
117 if (chdir(Cwd.c_str()) != 0)
118 chdir("/");
119
120 return true;
121 }
122 /*}}}*/
123 // DebFile::ExtractArchive - Extract the archive data itself /*{{{*/
124 // ---------------------------------------------------------------------
125 /* Simple wrapper around tar.. */
126 bool debDebFile::ExtractArchive(pkgDirStream &Stream)
127 {
128 // Get the archive member and positition the file
129 const ARArchive::Member *Member = AR.FindMember("data.tar.gz");
130 const char *Compressor = "gzip";
131 if (Member == 0) {
132 Member = AR.FindMember("data.tar.bz2");
133 Compressor = "bzip2";
134 }
135 if (Member == 0) {
136 Member = AR.FindMember("data.tar.lzma");
137 Compressor = "lzma";
138 }
139 if (Member == 0)
140 return _error->Error(_("Internal error, could not locate member"));
141 if (File.Seek(Member->Start) == false)
142 return false;
143
144 // Prepare Tar
145 ExtractTar Tar(File,Member->Size,Compressor);
146 if (_error->PendingError() == true)
147 return false;
148 return Tar.Go(Stream);
149 }
150 /*}}}*/
151 // DebFile::MergeControl - Merge the control information /*{{{*/
152 // ---------------------------------------------------------------------
153 /* This reads the extracted control file into the cache and returns the
154 version that was parsed. All this really does is select the correct
155 parser and correct file to parse. */
156 pkgCache::VerIterator debDebFile::MergeControl(pkgDataBase &DB)
157 {
158 // Open the control file
159 string Tmp;
160 if (DB.GetMetaTmp(Tmp) == false)
161 return pkgCache::VerIterator(DB.GetCache());
162 FileFd Fd(Tmp + "control",FileFd::ReadOnly);
163 if (_error->PendingError() == true)
164 return pkgCache::VerIterator(DB.GetCache());
165
166 // Parse it
167 debListParser Parse(&Fd);
168 pkgCache::VerIterator Ver(DB.GetCache());
169 if (DB.GetGenerator().MergeList(Parse,&Ver) == false)
170 return pkgCache::VerIterator(DB.GetCache());
171
172 if (Ver.end() == true)
173 _error->Error(_("Failed to locate a valid control file"));
174 return Ver;
175 }
176 /*}}}*/
177
178 // DebFile::ControlExtract::DoItem - Control Tar Extraction /*{{{*/
179 // ---------------------------------------------------------------------
180 /* This directory stream handler for the control tar handles extracting
181 it into the temporary meta directory. It only extracts files, it does
182 not create directories, links or anything else. */
183 bool debDebFile::ControlExtract::DoItem(Item &Itm,int &Fd)
184 {
185 if (Itm.Type != Item::File)
186 return true;
187
188 /* Cleanse the file name, prevent people from trying to unpack into
189 absolute paths, .., etc */
190 for (char *I = Itm.Name; *I != 0; I++)
191 if (*I == '/')
192 *I = '_';
193
194 /* Force the ownership to be root and ensure correct permissions,
195 go-w, the rest are left untouched */
196 Itm.UID = 0;
197 Itm.GID = 0;
198 Itm.Mode &= ~(S_IWGRP | S_IWOTH);
199
200 return pkgDirStream::DoItem(Itm,Fd);
201 }
202 /*}}}*/
203
204 // MemControlExtract::DoItem - Check if it is the control file /*{{{*/
205 // ---------------------------------------------------------------------
206 /* This sets up to extract the control block member file into a memory
207 block of just the right size. All other files go into the bit bucket. */
208 bool debDebFile::MemControlExtract::DoItem(Item &Itm,int &Fd)
209 {
210 // At the control file, allocate buffer memory.
211 if (Member == Itm.Name)
212 {
213 delete [] Control;
214 Control = new char[Itm.Size+2];
215 IsControl = true;
216 Fd = -2; // Signal to pass to Process
217 Length = Itm.Size;
218 }
219 else
220 IsControl = false;
221
222 return true;
223 }
224 /*}}}*/
225 // MemControlExtract::Process - Process extracting the control file /*{{{*/
226 // ---------------------------------------------------------------------
227 /* Just memcopy the block from the tar extractor and put it in the right
228 place in the pre-allocated memory block. */
229 bool debDebFile::MemControlExtract::Process(Item &Itm,const unsigned char *Data,
230 unsigned long Size,unsigned long Pos)
231 {
232 memcpy(Control + Pos, Data,Size);
233 return true;
234 }
235 /*}}}*/
236 // MemControlExtract::Read - Read the control information from the deb /*{{{*/
237 // ---------------------------------------------------------------------
238 /* This uses the internal tar extractor to fetch the control file, and then
239 it parses it into a tag section parser. */
240 bool debDebFile::MemControlExtract::Read(debDebFile &Deb)
241 {
242 // Get the archive member and positition the file
243 const ARArchive::Member *Member = Deb.GotoMember("control.tar.gz");
244 if (Member == 0)
245 return false;
246
247 // Extract it.
248 ExtractTar Tar(Deb.GetFile(),Member->Size,"gzip");
249 if (Tar.Go(*this) == false)
250 return false;
251
252 if (Control == 0)
253 return true;
254
255 Control[Length] = '\n';
256 Control[Length+1] = '\n';
257 if (Section.Scan(Control,Length+2) == false)
258 return _error->Error(_("Unparsable control file"));
259 return true;
260 }
261 /*}}}*/
262 // MemControlExtract::TakeControl - Parse a memory block /*{{{*/
263 // ---------------------------------------------------------------------
264 /* The given memory block is loaded into the parser and parsed as a control
265 record. */
266 bool debDebFile::MemControlExtract::TakeControl(const void *Data,unsigned long Size)
267 {
268 delete [] Control;
269 Control = new char[Size+2];
270 Length = Size;
271 memcpy(Control,Data,Size);
272
273 Control[Length] = '\n';
274 Control[Length+1] = '\n';
275 return Section.Scan(Control,Length+2);
276 }
277 /*}}}*/
278