Clarify the --help for 'purge' (LP: #243948)
[apt.git] / apt-inst / contrib / extracttar.cc
1 // -*- mode: cpp; mode: fold -*-
2 // Description /*{{{*/
3 // $Id: extracttar.cc,v 1.8.2.1 2004/01/16 18:58:50 mdz Exp $
4 /* ######################################################################
5
6 Extract a Tar - Tar Extractor
7
8 Some performance measurements showed that zlib performed quite poorly
9 in comparision to a forked gzip process. This tar extractor makes use
10 of the fact that dup'd file descriptors have the same seek pointer
11 and that gzip will not read past the end of a compressed stream,
12 even if there is more data. We use the dup property to track extraction
13 progress and the gzip feature to just feed gzip a fd in the middle
14 of an AR file.
15
16 ##################################################################### */
17 /*}}}*/
18 // Include Files /*{{{*/
19 #include <apt-pkg/extracttar.h>
20
21 #include <apt-pkg/error.h>
22 #include <apt-pkg/strutl.h>
23 #include <apt-pkg/configuration.h>
24 #include <system.h>
25
26 #include <stdlib.h>
27 #include <unistd.h>
28 #include <signal.h>
29 #include <fcntl.h>
30 #include <iostream>
31 #include <apti18n.h>
32 /*}}}*/
33
34 using namespace std;
35
36 // The on disk header for a tar file.
37 struct ExtractTar::TarHeader
38 {
39 char Name[100];
40 char Mode[8];
41 char UserID[8];
42 char GroupID[8];
43 char Size[12];
44 char MTime[12];
45 char Checksum[8];
46 char LinkFlag;
47 char LinkName[100];
48 char MagicNumber[8];
49 char UserName[32];
50 char GroupName[32];
51 char Major[8];
52 char Minor[8];
53 };
54
55 // ExtractTar::ExtractTar - Constructor /*{{{*/
56 // ---------------------------------------------------------------------
57 /* */
58 ExtractTar::ExtractTar(FileFd &Fd,unsigned long Max,string DecompressionProgram) : File(Fd),
59 MaxInSize(Max), DecompressProg(DecompressionProgram)
60
61 {
62 GZPid = -1;
63 InFd = -1;
64 Eof = false;
65 }
66 /*}}}*/
67 // ExtractTar::ExtractTar - Destructor /*{{{*/
68 // ---------------------------------------------------------------------
69 /* */
70 ExtractTar::~ExtractTar()
71 {
72 // Error close
73 Done(true);
74 }
75 /*}}}*/
76 // ExtractTar::Done - Reap the gzip sub process /*{{{*/
77 // ---------------------------------------------------------------------
78 /* If the force flag is given then error messages are suppressed - this
79 means we hit the end of the tar file but there was still gzip data. */
80 bool ExtractTar::Done(bool Force)
81 {
82 InFd.Close();
83 if (GZPid <= 0)
84 return true;
85
86 /* If there is a pending error then we are cleaning up gzip and are
87 not interested in it's failures */
88 if (_error->PendingError() == true)
89 Force = true;
90
91 // Make sure we clean it up!
92 kill(GZPid,SIGINT);
93 string confvar = string("dir::bin::") + DecompressProg;
94 if (ExecWait(GZPid,_config->Find(confvar.c_str(),DecompressProg.c_str()).c_str(),
95 Force) == false)
96 {
97 GZPid = -1;
98 return Force;
99 }
100
101 GZPid = -1;
102 return true;
103 }
104 /*}}}*/
105 // ExtractTar::StartGzip - Startup gzip /*{{{*/
106 // ---------------------------------------------------------------------
107 /* This creates a gzip sub process that has its input as the file itself.
108 If this tar file is embedded into something like an ar file then
109 gzip will efficiently ignore the extra bits. */
110 bool ExtractTar::StartGzip()
111 {
112 int Pipes[2];
113 if (pipe(Pipes) != 0)
114 return _error->Errno("pipe",_("Failed to create pipes"));
115
116 // Fork off the process
117 GZPid = ExecFork();
118
119 // Spawn the subprocess
120 if (GZPid == 0)
121 {
122 // Setup the FDs
123 dup2(Pipes[1],STDOUT_FILENO);
124 dup2(File.Fd(),STDIN_FILENO);
125 int Fd = open("/dev/null",O_RDWR);
126 if (Fd == -1)
127 _exit(101);
128 dup2(Fd,STDERR_FILENO);
129 close(Fd);
130 SetCloseExec(STDOUT_FILENO,false);
131 SetCloseExec(STDIN_FILENO,false);
132 SetCloseExec(STDERR_FILENO,false);
133
134 const char *Args[3];
135 string confvar = string("dir::bin::") + DecompressProg;
136 string argv0 = _config->Find(confvar.c_str(),DecompressProg.c_str());
137 Args[0] = argv0.c_str();
138 Args[1] = "-d";
139 Args[2] = 0;
140 execvp(Args[0],(char **)Args);
141 cerr << _("Failed to exec gzip ") << Args[0] << endl;
142 _exit(100);
143 }
144
145 // Fix up our FDs
146 InFd.Fd(Pipes[0]);
147 close(Pipes[1]);
148 return true;
149 }
150 /*}}}*/
151 // ExtractTar::Go - Perform extraction /*{{{*/
152 // ---------------------------------------------------------------------
153 /* This reads each 512 byte block from the archive and extracts the header
154 information into the Item structure. Then it resolves the UID/GID and
155 invokes the correct processing function. */
156 bool ExtractTar::Go(pkgDirStream &Stream)
157 {
158 if (StartGzip() == false)
159 return false;
160
161 // Loop over all blocks
162 string LastLongLink;
163 string LastLongName;
164 while (1)
165 {
166 bool BadRecord = false;
167 unsigned char Block[512];
168 if (InFd.Read(Block,sizeof(Block),true) == false)
169 return false;
170
171 if (InFd.Eof() == true)
172 break;
173
174 // Get the checksum
175 TarHeader *Tar = (TarHeader *)Block;
176 unsigned long CheckSum;
177 if (StrToNum(Tar->Checksum,CheckSum,sizeof(Tar->Checksum),8) == false)
178 return _error->Error(_("Corrupted archive"));
179
180 /* Compute the checksum field. The actual checksum is blanked out
181 with spaces so it is not included in the computation */
182 unsigned long NewSum = 0;
183 memset(Tar->Checksum,' ',sizeof(Tar->Checksum));
184 for (int I = 0; I != sizeof(Block); I++)
185 NewSum += Block[I];
186
187 /* Check for a block of nulls - in this case we kill gzip, GNU tar
188 does this.. */
189 if (NewSum == ' '*sizeof(Tar->Checksum))
190 return Done(true);
191
192 if (NewSum != CheckSum)
193 return _error->Error(_("Tar checksum failed, archive corrupted"));
194
195 // Decode all of the fields
196 pkgDirStream::Item Itm;
197 if (StrToNum(Tar->Mode,Itm.Mode,sizeof(Tar->Mode),8) == false ||
198 StrToNum(Tar->UserID,Itm.UID,sizeof(Tar->UserID),8) == false ||
199 StrToNum(Tar->GroupID,Itm.GID,sizeof(Tar->GroupID),8) == false ||
200 StrToNum(Tar->Size,Itm.Size,sizeof(Tar->Size),8) == false ||
201 StrToNum(Tar->MTime,Itm.MTime,sizeof(Tar->MTime),8) == false ||
202 StrToNum(Tar->Major,Itm.Major,sizeof(Tar->Major),8) == false ||
203 StrToNum(Tar->Minor,Itm.Minor,sizeof(Tar->Minor),8) == false)
204 return _error->Error(_("Corrupted archive"));
205
206 // Grab the filename
207 if (LastLongName.empty() == false)
208 Itm.Name = (char *)LastLongName.c_str();
209 else
210 {
211 Tar->Name[sizeof(Tar->Name)-1] = 0;
212 Itm.Name = Tar->Name;
213 }
214 if (Itm.Name[0] == '.' && Itm.Name[1] == '/' && Itm.Name[2] != 0)
215 Itm.Name += 2;
216
217 // Grab the link target
218 Tar->Name[sizeof(Tar->LinkName)-1] = 0;
219 Itm.LinkTarget = Tar->LinkName;
220
221 if (LastLongLink.empty() == false)
222 Itm.LinkTarget = (char *)LastLongLink.c_str();
223
224 // Convert the type over
225 switch (Tar->LinkFlag)
226 {
227 case NormalFile0:
228 case NormalFile:
229 Itm.Type = pkgDirStream::Item::File;
230 break;
231
232 case HardLink:
233 Itm.Type = pkgDirStream::Item::HardLink;
234 break;
235
236 case SymbolicLink:
237 Itm.Type = pkgDirStream::Item::SymbolicLink;
238 break;
239
240 case CharacterDevice:
241 Itm.Type = pkgDirStream::Item::CharDevice;
242 break;
243
244 case BlockDevice:
245 Itm.Type = pkgDirStream::Item::BlockDevice;
246 break;
247
248 case Directory:
249 Itm.Type = pkgDirStream::Item::Directory;
250 break;
251
252 case FIFO:
253 Itm.Type = pkgDirStream::Item::FIFO;
254 break;
255
256 case GNU_LongLink:
257 {
258 unsigned long Length = Itm.Size;
259 unsigned char Block[512];
260 while (Length > 0)
261 {
262 if (InFd.Read(Block,sizeof(Block),true) == false)
263 return false;
264 if (Length <= sizeof(Block))
265 {
266 LastLongLink.append(Block,Block+sizeof(Block));
267 break;
268 }
269 LastLongLink.append(Block,Block+sizeof(Block));
270 Length -= sizeof(Block);
271 }
272 continue;
273 }
274
275 case GNU_LongName:
276 {
277 unsigned long Length = Itm.Size;
278 unsigned char Block[512];
279 while (Length > 0)
280 {
281 if (InFd.Read(Block,sizeof(Block),true) == false)
282 return false;
283 if (Length < sizeof(Block))
284 {
285 LastLongName.append(Block,Block+sizeof(Block));
286 break;
287 }
288 LastLongName.append(Block,Block+sizeof(Block));
289 Length -= sizeof(Block);
290 }
291 continue;
292 }
293
294 default:
295 BadRecord = true;
296 _error->Warning(_("Unknown TAR header type %u, member %s"),(unsigned)Tar->LinkFlag,Tar->Name);
297 break;
298 }
299
300 int Fd = -1;
301 if (BadRecord == false)
302 if (Stream.DoItem(Itm,Fd) == false)
303 return false;
304
305 // Copy the file over the FD
306 unsigned long Size = Itm.Size;
307 while (Size != 0)
308 {
309 unsigned char Junk[32*1024];
310 unsigned long Read = min(Size,(unsigned long)sizeof(Junk));
311 if (InFd.Read(Junk,((Read+511)/512)*512) == false)
312 return false;
313
314 if (BadRecord == false)
315 {
316 if (Fd > 0)
317 {
318 if (write(Fd,Junk,Read) != (signed)Read)
319 return Stream.Fail(Itm,Fd);
320 }
321 else
322 {
323 /* An Fd of -2 means to send to a special processing
324 function */
325 if (Fd == -2)
326 if (Stream.Process(Itm,Junk,Read,Itm.Size - Size) == false)
327 return Stream.Fail(Itm,Fd);
328 }
329 }
330
331 Size -= Read;
332 }
333
334 // And finish up
335 if (Itm.Size >= 0 && BadRecord == false)
336 if (Stream.FinishedFile(Itm,Fd) == false)
337 return false;
338
339 LastLongName.erase();
340 LastLongLink.erase();
341 }
342
343 return Done(false);
344 }
345 /*}}}*/