[thirdparty/tar.git] / src / delete.c

/* Delete entries from a tar archive.

   Copyright 1988-2025 Free Software Foundation, Inc.

   This file is part of GNU tar.

   GNU tar is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   GNU tar is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include <system.h>

#include "common.h"
#include <rmt.h>

static union block *new_record;
static idx_t new_blocks;
static bool acting_as_filter;

/* The number of records skipped at the start of the archive, when
   passing over members that are not deleted.  */
off_t records_skipped;

/* Move archive descriptor by COUNT records worth.  If COUNT is
   positive we move forward, else we move negative.  If it's a tape,
   MTIOCTOP had better work.  If it's something else, we try to seek
   on it.  If we can't seek, we lose!  */
static void
move_archive (off_t count)
{
  if (count == 0)
    return;

  if (mtioseek (false, count))
    return;

  off_t position0 = rmtlseek (archive, 0, SEEK_CUR), position = 0;
  if (0 <= position0)
    {
      /* Pretend the starting position is at the first record
	 boundary after POSITION0.  This is useful at EOF after
	 a short read.  */
      idx_t short_size = position0 % record_size;
      idx_t start_offset = short_size ? record_size - short_size : 0;
      off_t increment, move_start;
      if (ckd_mul (&increment, record_size, count)
	  || ckd_add (&move_start, position0, start_offset)
	  || ckd_add (&position, move_start, increment)
	  || position < 0)
	{
	  paxerror (EOVERFLOW, "lseek: %s", archive_name_array[0]);
	  return;
	}
      else if (rmtlseek (archive, position, SEEK_SET) == position)
	return;
    }
  if (!_isrmt (archive))
    seek_error_details (archive_name_array[0], position);
}

/* Write out the record which has been filled.  If MOVE_BACK_FLAG,
   backspace to where we started.  */
static void
write_record (bool move_back_flag)
{
  union block *save_record = record_start;
  record_start = new_record;

  if (acting_as_filter)
    {
      archive = STDOUT_FILENO;
      flush_write ();
      archive = STDIN_FILENO;
    }
  else
    {
      move_archive ((records_written + records_skipped) - records_read);
      flush_write ();
    }

  record_start = save_record;

  if (move_back_flag)
    {
      /* Move the tape head back to where we were.  */

      if (! acting_as_filter)
	move_archive (records_read - (records_written + records_skipped));
    }

  new_blocks = 0;
}

static void
write_recent_blocks (union block *h, idx_t blocks)
{
  for (idx_t i = 0; i < blocks; i++)
    {
      new_record[new_blocks++] = h[i];
      if (new_blocks == blocking_factor)
	write_record (true);
    }
}

static void
write_recent_bytes (char *data, idx_t bytes)
{
  idx_t blocks = bytes >> LG_BLOCKSIZE;
  idx_t rest = bytes & (BLOCKSIZE - 1);

  write_recent_blocks ((union block *)data, blocks);
  memcpy (new_record[new_blocks].buffer, data + blocks * BLOCKSIZE, rest);
  if (rest < BLOCKSIZE)
    memset (new_record[new_blocks].buffer + rest, 0, BLOCKSIZE - rest);
  new_blocks++;
  if (new_blocks == blocking_factor)
    write_record (true);
}

static void
flush_file (void)
{
  set_next_block_after (current_header);
  off_t size = current_stat_info.stat.st_size;
  off_t blocks_to_skip = (size >> LG_BLOCKSIZE) + !!(size & (BLOCKSIZE - 1));

  while (record_end - current_block <= blocks_to_skip)
    {
      blocks_to_skip -= (record_end - current_block);
      flush_archive ();
      if (record_end == current_block)
	/* Hit EOF */
	return;
    }
  current_block += blocks_to_skip;
}

void
delete_archive_members (void)
{
  enum read_header logical_status = HEADER_STILL_UNREAD;
  enum read_header previous_status = HEADER_STILL_UNREAD;

  /* FIXME: Should clean the routine before cleaning these variables :-( */
  struct name *name;
  off_t blocks_to_keep = 0;
  ptrdiff_t kept_blocks_in_record;

  name_gather ();
  open_archive (ACCESS_UPDATE);
  acting_as_filter = strcmp (archive_name_array[0], "-") == 0;

  /* Skip to the first member that matches the name list. */
  do
    {
      enum read_header status = read_header (&current_header,
					     &current_stat_info,
					     read_header_x_raw);

      switch (status)
	{
	case HEADER_STILL_UNREAD:
	  abort ();

	case HEADER_SUCCESS:
	  if ((name = name_scan (current_stat_info.file_name, false)) == NULL)
	    {
	      skim_member (acting_as_filter);
	      break;
	    }
	  name->found_count++;
	  if (!isfound (name))
	    {
	      skim_member (acting_as_filter);
	      break;
	    }
	  FALLTHROUGH;
	case HEADER_SUCCESS_EXTENDED:
	  logical_status = status;
	  break;

	case HEADER_ZERO_BLOCK:
	  if (ignore_zeros_option)
	    {
	      set_next_block_after (current_header);
	      break;
	    }
	  FALLTHROUGH;
	case HEADER_END_OF_FILE:
	  logical_status = HEADER_END_OF_FILE;
	  break;

	case HEADER_FAILURE:
	  set_next_block_after (current_header);
	  switch (previous_status)
	    {
	    case HEADER_STILL_UNREAD:
	      paxwarn (0, _("This does not look like a tar archive"));
	      FALLTHROUGH;
	    case HEADER_SUCCESS:
	    case HEADER_SUCCESS_EXTENDED:
	    case HEADER_ZERO_BLOCK:
	      paxerror (0, _("Skipping to next header"));
	      FALLTHROUGH;
	    case HEADER_FAILURE:
	      break;

	    case HEADER_END_OF_FILE:
	      abort ();
	    }
	  break;
	}

      previous_status = status;
    }
  while (logical_status == HEADER_STILL_UNREAD);

  records_skipped = records_read - 1;
  new_record = xmalloc (record_size);

  if (logical_status == HEADER_SUCCESS
      || logical_status == HEADER_SUCCESS_EXTENDED)
    {
      write_archive_to_stdout = false;

      /* Save away blocks before this one in this record.  */

      new_blocks = current_block - record_start;
      if (new_blocks)
	memcpy (new_record, record_start, new_blocks * BLOCKSIZE);

      if (logical_status == HEADER_SUCCESS)
	{
	  logical_status = HEADER_STILL_UNREAD;
	  flush_file ();
	}

      /* Skip matching members and move the rest up the archive. */
      while (logical_status != HEADER_END_OF_FILE)
	{
	  enum read_header status;

	  /* Fill in a record.  */

	  if (current_block == record_end)
	    flush_archive ();

	  status = read_header (&current_header, &current_stat_info,
				read_header_auto);

	  switch (status)
	    {
	    case HEADER_STILL_UNREAD:
	    case HEADER_SUCCESS_EXTENDED:
	      abort ();

	    case HEADER_SUCCESS:
	      /* Found another header.  */
	      xheader_decode (&current_stat_info);

	      if ((name = name_scan (current_stat_info.file_name, false)) != NULL)
		{
		  name->found_count++;
		  if (isfound (name))
		    {
		      flush_file ();
		      break;
		    }
		}
	      /* Copy header.  */

	      if (current_stat_info.xhdr.size)
		{
		  write_recent_bytes (current_stat_info.xhdr.buffer,
				      current_stat_info.xhdr.size);
		}
	      else
		{
		  write_recent_blocks (recent_long_name,
				       recent_long_name_blocks);
		  write_recent_blocks (recent_long_link,
				       recent_long_link_blocks);
		}
	      new_record[new_blocks] = *current_header;
	      new_blocks++;
	      blocks_to_keep
		= ((current_stat_info.stat.st_size >> LG_BLOCKSIZE)
		   + !!(current_stat_info.stat.st_size & (BLOCKSIZE - 1)));
	      set_next_block_after (current_header);
	      if (new_blocks == blocking_factor)
		write_record (true);

	      /* Copy data.  */

	      kept_blocks_in_record = record_end - current_block;
	      if (kept_blocks_in_record > blocks_to_keep)
		kept_blocks_in_record = blocks_to_keep;

	      while (blocks_to_keep)
		{
		  ptrdiff_t count;

		  if (current_block == record_end)
		    {
		      flush_read ();
		      current_block = record_start;
		      kept_blocks_in_record = blocking_factor;
		      if (kept_blocks_in_record > blocks_to_keep)
			kept_blocks_in_record = blocks_to_keep;
		    }
		  count = kept_blocks_in_record;
		  if (blocking_factor - new_blocks < count)
		    count = blocking_factor - new_blocks;

		  if (! count)
		    abort ();

		  memcpy (new_record + new_blocks, current_block,
			  count * BLOCKSIZE);
		  new_blocks += count;
		  current_block += count;
		  blocks_to_keep -= count;
		  kept_blocks_in_record -= count;

		  if (new_blocks == blocking_factor)
		    write_record (true);
		}
	      break;

	    case HEADER_ZERO_BLOCK:
	      if (ignore_zeros_option)
		set_next_block_after (current_header);
	      else
		logical_status = HEADER_END_OF_FILE;
	      break;

	    case HEADER_END_OF_FILE:
	      logical_status = HEADER_END_OF_FILE;
	      break;

	    case HEADER_FAILURE:
	      paxerror (0, _("Deleting non-header from archive"));
	      set_next_block_after (current_header);
	      break;

	    default:
	      abort ();
	    }
	  tar_stat_destroy (&current_stat_info);
	}

      if (logical_status == HEADER_END_OF_FILE)
	{
	  /* Write the end of tape.  FIXME: we can't use write_eot here,
	     as it gets confused when the input is at end of file.  */

	  idx_t total_zero_blocks = 0;

	  do
	    {
	      idx_t zero_blocks = blocking_factor - new_blocks;
	      memset (new_record + new_blocks, 0, BLOCKSIZE * zero_blocks);
	      total_zero_blocks += zero_blocks;
	      write_record (total_zero_blocks < 2);
	    }
	  while (total_zero_blocks < 2);
	}

      if (! acting_as_filter && ! _isrmt (archive))
	{
	  if (sys_truncate (archive) < 0)
	    truncate_warn (archive_name_array[0]);
	}
    }
  free (new_record);

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