source: vendor/tar/1.16.1/src/delete.c

Last change on this file was 3342, checked in by bird, 19 years ago

tar 1.16.1
File size: 9.7 KB
Line 
1/* Delete entries from a tar archive.
2
3 Copyright (C) 1988, 1992, 1994, 1996, 1997, 2000, 2001, 2003, 2004,
4 2005, 2006 Free Software Foundation, Inc.
5
6 This program is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 2, or (at your option) any later
9 version.
10
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
14 Public License for more details.
15
16 You should have received a copy of the GNU General Public License along
17 with this program; if not, write to the Free Software Foundation, Inc.,
18 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
19
20#include <system.h>
21#include <system-ioctl.h>
22
23#include "common.h"
24#include <rmt.h>
25
26static union block *new_record;
27static int new_blocks;
28static bool acting_as_filter;
29
30/* FIXME: This module should not directly handle the following
31 variables, instead, the interface should be cleaned up. */
32extern union block *record_start;
33extern union block *record_end;
34extern union block *current_block;
35extern union block *recent_long_name;
36extern union block *recent_long_link;
37extern off_t records_read;
38extern off_t records_written;
39
40/* The number of records skipped at the start of the archive, when
41 passing over members that are not deleted. */
42off_t records_skipped;
43
44/* Move archive descriptor by COUNT records worth. If COUNT is
45 positive we move forward, else we move negative. If it's a tape,
46 MTIOCTOP had better work. If it's something else, we try to seek
47 on it. If we can't seek, we lose! */
48static void
49move_archive (off_t count)
50{
51 if (count == 0)
52 return;
53
54#ifdef MTIOCTOP
55 {
56 struct mtop operation;
57
58 if (count < 0
59 ? (operation.mt_op = MTBSR,
60 operation.mt_count = -count,
61 operation.mt_count == -count)
62 : (operation.mt_op = MTFSR,
63 operation.mt_count = count,
64 operation.mt_count == count))
65 {
66 if (0 <= rmtioctl (archive, MTIOCTOP, (char *) &operation))
67 return;
68
69 if (errno == EIO
70 && 0 <= rmtioctl (archive, MTIOCTOP, (char *) &operation))
71 return;
72 }
73 }
74#endif /* MTIOCTOP */
75
76 {
77 off_t position0 = rmtlseek (archive, (off_t) 0, SEEK_CUR);
78 off_t increment = record_size * (off_t) count;
79 off_t position = position0 + increment;
80
81 if (increment / count != record_size
82 || (position < position0) != (increment < 0)
83 || (position = position < 0 ? 0 : position,
84 rmtlseek (archive, position, SEEK_SET) != position))
85 seek_error_details (archive_name_array[0], position);
86
87 return;
88 }
89}
90
91/* Write out the record which has been filled. If MOVE_BACK_FLAG,
92 backspace to where we started. */
93static void
94write_record (int move_back_flag)
95{
96 union block *save_record = record_start;
97 record_start = new_record;
98
99 if (acting_as_filter)
100 {
101 archive = STDOUT_FILENO;
102 flush_write ();
103 archive = STDIN_FILENO;
104 }
105 else
106 {
107 move_archive ((records_written + records_skipped) - records_read);
108 flush_write ();
109 }
110
111 record_start = save_record;
112
113 if (move_back_flag)
114 {
115 /* Move the tape head back to where we were. */
116
117 if (! acting_as_filter)
118 move_archive (records_read - (records_written + records_skipped));
119 }
120
121 new_blocks = 0;
122}
123
124static void
125write_recent_blocks (union block *h, size_t blocks)
126{
127 size_t i;
128 for (i = 0; i < blocks; i++)
129 {
130 new_record[new_blocks++] = h[i];
131 if (new_blocks == blocking_factor)
132 write_record (1);
133 }
134}
135
136static void
137write_recent_bytes (char *data, size_t bytes)
138{
139 size_t blocks = bytes / BLOCKSIZE;
140 size_t rest = bytes - blocks * BLOCKSIZE;
141
142 write_recent_blocks ((union block *)data, blocks);
143 memcpy (new_record[new_blocks].buffer, data + blocks * BLOCKSIZE, rest);
144 if (rest < BLOCKSIZE)
145 memset (new_record[new_blocks].buffer + rest, 0, BLOCKSIZE - rest);
146 new_blocks++;
147 if (new_blocks == blocking_factor)
148 write_record (1);
149}
150
151void
152delete_archive_members (void)
153{
154 enum read_header logical_status = HEADER_STILL_UNREAD;
155 enum read_header previous_status = HEADER_STILL_UNREAD;
156
157 /* FIXME: Should clean the routine before cleaning these variables :-( */
158 struct name *name;
159 off_t blocks_to_skip = 0;
160 off_t blocks_to_keep = 0;
161 int kept_blocks_in_record;
162
163 name_gather ();
164 open_archive (ACCESS_UPDATE);
165 acting_as_filter = strcmp (archive_name_array[0], "-") == 0;
166
167 do
168 {
169 enum read_header status = read_header (true);
170
171 switch (status)
172 {
173 case HEADER_STILL_UNREAD:
174 abort ();
175
176 case HEADER_SUCCESS:
177 if ((name = name_scan (current_stat_info.file_name)) == NULL)
178 {
179 skip_member ();
180 break;
181 }
182 name->found_count++;
183 if (!ISFOUND(name))
184 {
185 skip_member ();
186 break;
187 }
188
189 /* Fall through. */
190 case HEADER_SUCCESS_EXTENDED:
191 logical_status = status;
192 break;
193
194 case HEADER_ZERO_BLOCK:
195 if (ignore_zeros_option)
196 {
197 set_next_block_after (current_header);
198 break;
199 }
200 /* Fall through. */
201 case HEADER_END_OF_FILE:
202 logical_status = HEADER_END_OF_FILE;
203 break;
204
205 case HEADER_FAILURE:
206 set_next_block_after (current_header);
207 switch (previous_status)
208 {
209 case HEADER_STILL_UNREAD:
210 WARN ((0, 0, _("This does not look like a tar archive")));
211 /* Fall through. */
212
213 case HEADER_SUCCESS:
214 case HEADER_SUCCESS_EXTENDED:
215 case HEADER_ZERO_BLOCK:
216 ERROR ((0, 0, _("Skipping to next header")));
217 /* Fall through. */
218
219 case HEADER_FAILURE:
220 break;
221
222 case HEADER_END_OF_FILE:
223 abort ();
224 }
225 break;
226 }
227
228 previous_status = status;
229 }
230 while (logical_status == HEADER_STILL_UNREAD);
231
232 records_skipped = records_read - 1;
233 new_record = xmalloc (record_size);
234
235 if (logical_status == HEADER_SUCCESS
236 || logical_status == HEADER_SUCCESS_EXTENDED)
237 {
238 write_archive_to_stdout = false;
239
240 /* Save away blocks before this one in this record. */
241
242 new_blocks = current_block - record_start;
243 if (new_blocks)
244 memcpy (new_record, record_start, new_blocks * BLOCKSIZE);
245
246 if (logical_status == HEADER_SUCCESS)
247 {
248 /* FIXME: Pheew! This is crufty code! */
249 logical_status = HEADER_STILL_UNREAD;
250 goto flush_file;
251 }
252
253 /* FIXME: Solaris 2.4 Sun cc (the ANSI one, not the old K&R) says:
254 "delete.c", line 223: warning: loop not entered at top
255 Reported by Bruno Haible. */
256 while (1)
257 {
258 enum read_header status;
259
260 /* Fill in a record. */
261
262 if (current_block == record_end)
263 flush_archive ();
264 status = read_header (false);
265
266 xheader_decode (&current_stat_info);
267
268 if (status == HEADER_ZERO_BLOCK && ignore_zeros_option)
269 {
270 set_next_block_after (current_header);
271 continue;
272 }
273 if (status == HEADER_END_OF_FILE || status == HEADER_ZERO_BLOCK)
274 {
275 logical_status = HEADER_END_OF_FILE;
276 break;
277 }
278
279 if (status == HEADER_FAILURE)
280 {
281 ERROR ((0, 0, _("Deleting non-header from archive")));
282 set_next_block_after (current_header);
283 continue;
284 }
285
286 /* Found another header. */
287
288 if ((name = name_scan (current_stat_info.file_name)) != NULL)
289 {
290 name->found_count++;
291 if (ISFOUND(name))
292 {
293 flush_file:
294 set_next_block_after (current_header);
295 blocks_to_skip = (current_stat_info.stat.st_size
296 + BLOCKSIZE - 1) / BLOCKSIZE;
297
298 while (record_end - current_block <= blocks_to_skip)
299 {
300 blocks_to_skip -= (record_end - current_block);
301 flush_archive ();
302 }
303 current_block += blocks_to_skip;
304 blocks_to_skip = 0;
305 continue;
306 }
307 }
308 /* Copy header. */
309
310 if (extended_header.size)
311 {
312 write_recent_bytes (extended_header.buffer,
313 extended_header.size);
314 }
315 else
316 {
317 write_recent_blocks (recent_long_name, recent_long_name_blocks);
318 write_recent_blocks (recent_long_link, recent_long_link_blocks);
319 }
320 new_record[new_blocks] = *current_header;
321 new_blocks++;
322 blocks_to_keep
323 = (current_stat_info.stat.st_size + BLOCKSIZE - 1) / BLOCKSIZE;
324 set_next_block_after (current_header);
325 if (new_blocks == blocking_factor)
326 write_record (1);
327
328 /* Copy data. */
329
330 kept_blocks_in_record = record_end - current_block;
331 if (kept_blocks_in_record > blocks_to_keep)
332 kept_blocks_in_record = blocks_to_keep;
333
334 while (blocks_to_keep)
335 {
336 int count;
337
338 if (current_block == record_end)
339 {
340 flush_read ();
341 current_block = record_start;
342 kept_blocks_in_record = blocking_factor;
343 if (kept_blocks_in_record > blocks_to_keep)
344 kept_blocks_in_record = blocks_to_keep;
345 }
346 count = kept_blocks_in_record;
347 if (blocking_factor - new_blocks < count)
348 count = blocking_factor - new_blocks;
349
350 if (! count)
351 abort ();
352
353 memcpy (new_record + new_blocks, current_block, count * BLOCKSIZE);
354 new_blocks += count;
355 current_block += count;
356 blocks_to_keep -= count;
357 kept_blocks_in_record -= count;
358
359 if (new_blocks == blocking_factor)
360 write_record (1);
361 }
362 }
363
364 if (logical_status == HEADER_END_OF_FILE)
365 {
366 /* Write the end of tape. FIXME: we can't use write_eot here,
367 as it gets confused when the input is at end of file. */
368
369 int total_zero_blocks = 0;
370
371 do
372 {
373 int zero_blocks = blocking_factor - new_blocks;
374 memset (new_record + new_blocks, 0, BLOCKSIZE * zero_blocks);
375 total_zero_blocks += zero_blocks;
376 write_record (total_zero_blocks < 2);
377 }
378 while (total_zero_blocks < 2);
379 }
380
381 if (! acting_as_filter && ! _isrmt (archive))
382 {
383 if (sys_truncate (archive))
384 truncate_warn (archive_name_array[0]);
385 }
386 }
387 free (new_record);
388
389 close_archive ();
390 names_notfound ();
391}
Note: See TracBrowser for help on using the repository browser.