freebsd-dev/gnu/usr.bin/tar/list.c

/* List a tar archive.
   Copyright (C) 1988, 1992, 1993 Free Software Foundation

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 2, 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 GNU Tar; see the file COPYING.  If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */

/*
 * List a tar archive.
 *
 * Also includes support routines for reading a tar archive.
 *
 * this version written 26 Aug 1985 by John Gilmore (ihnp4!hoptoad!gnu).
 */

#include <stdio.h>
#include <ctype.h>
#include <sys/types.h>
#include <errno.h>
#ifndef STDC_HEADERS
extern int errno;
#endif
#include <time.h>

#ifdef BSD42
#include <sys/file.h>
#else
#ifndef V7
#include <fcntl.h>
#endif
#endif

#define	isodigit(c)	( ((c) >= '0') && ((c) <= '7') )

#include "tar.h"
#include "port.h"

extern FILE *msg_file;

long from_oct ();		/* Decode octal number */
void demode ();			/* Print file mode */
void restore_saved_dir_info ();
PTR ck_malloc ();

union record *head;		/* Points to current archive header */
struct stat hstat;		/* Stat struct corresponding */
int head_standard;		/* Tape header is in ANSI format */

int check_exclude ();
void close_archive ();
void decode_header ();
int findgid ();
int finduid ();
void name_gather ();
int name_match ();
void names_notfound ();
void open_archive ();
void print_header ();
int read_header ();
void saverec ();
void skip_file ();
void skip_extended_headers ();

extern char *quote_copy_string ();


/*
 * Main loop for reading an archive.
 */
void
read_and (do_something)
     void (*do_something) ();
{
  int status = 3;		/* Initial status at start of archive */
  int prev_status;
  extern time_t new_time;
  char save_linkflag;

  name_gather ();		/* Gather all the names */
  open_archive (1);		/* Open for reading */

  for (;;)
    {
      prev_status = status;
      status = read_header ();
	/* check if the namelist got emptied during the course of reading */
	/* the tape, if so stop by setting status to EOF */
      if ((namelist == NULL) && nlpsfreed) {
	  status = EOF;
      }
      switch (status)
	{

	case 1:		/* Valid header */
	  /* We should decode next field (mode) first... */
	  /* Ensure incoming names are null terminated. */

	  if (!name_match (current_file_name)
	      || (f_new_files && hstat.st_mtime < new_time)
	      || (f_exclude && check_exclude (current_file_name)))
	    {

	      int isextended = 0;

	      if (head->header.linkflag == LF_VOLHDR
		  || head->header.linkflag == LF_MULTIVOL
		  || head->header.linkflag == LF_NAMES)
		{
		  (*do_something) ();
		  continue;
		}
	      if (f_show_omitted_dirs
		  && head->header.linkflag == LF_DIR)
		msg ("Omitting %s\n", current_file_name);
	      /* Skip past it in the archive */
	      if (head->header.isextended)
		isextended = 1;
	      save_linkflag = head->header.linkflag;
	      userec (head);
	      if (isextended)
		{
		  /*					register union record *exhdr;

					for (;;) {
					    exhdr = findrec();
					    if (!exhdr->ext_hdr.isextended) {
					    	userec(exhdr);
					    	break;
					    }
					}
					userec(exhdr);*/
		  skip_extended_headers ();
		}
	      /* Skip to the next header on the archive */
	      if (save_linkflag != LF_DIR)
		skip_file ((long) hstat.st_size);
	      continue;

	    }

	  (*do_something) ();
	  continue;

	  /*
			 * If the previous header was good, tell them
			 * that we are skipping bad ones.
			 */
	case 0:		/* Invalid header */
	  userec (head);
	  switch (prev_status)
	    {
	    case 3:		/* Error on first record */
	      msg ("Hmm, this doesn't look like a tar archive.");
	      /* FALL THRU */
	    case 2:		/* Error after record of zeroes */
	    case 1:		/* Error after header rec */
	      msg ("Skipping to next file header...");
	    case 0:		/* Error after error */
	      break;
	    }
	  continue;

	case 2:		/* Record of zeroes */
	  userec (head);
	  status = prev_status;	/* If error after 0's */
	  if (f_ignorez)
	    continue;
	  /* FALL THRU */
	case EOF:		/* End of archive */
	  break;
	}
      break;
    };

  restore_saved_dir_info ();
  close_archive ();
  names_notfound ();		/* Print names not found */
}


/*
 * Print a header record, based on tar options.
 */
void
list_archive ()
{
  extern char *save_name;
  int isextended = 0;		/* Flag to remember if head is extended */

  /* Save the record */
  saverec (&head);

  /* Print the header record */
  if (f_verbose)
    {
      if (f_verbose > 1)
	decode_header (head, &hstat, &head_standard, 0);
      print_header ();
    }

  if (f_gnudump && head->header.linkflag == LF_DUMPDIR)
    {
      size_t size, written, check;
      char *data;
      extern long save_totsize;
      extern long save_sizeleft;

      userec (head);
      if (f_multivol)
	{
	  save_name = current_file_name;
	  save_totsize = hstat.st_size;
	}
      for (size = hstat.st_size; size > 0; size -= written)
	{
	  if (f_multivol)
	    save_sizeleft = size;
	  data = findrec ()->charptr;
	  if (data == NULL)
	    {
	      msg ("EOF in archive file?");
	      break;
	    }
	  written = endofrecs ()->charptr - data;
	  if (written > size)
	    written = size;
	  errno = 0;
	  check = fwrite (data, sizeof (char), written, msg_file);
	  userec ((union record *) (data + written - 1));
	  if (check != written)
	    {
	      msg_perror ("only wrote %ld of %ld bytes to file %s", check, written, current_file_name);
	      skip_file ((long) (size) - written);
	      break;
	    }
	}
      if (f_multivol)
	save_name = 0;
      saverec ((union record **) 0);	/* Unsave it */
      fputc ('\n', msg_file);
      fflush (msg_file);
      return;

    }
  saverec ((union record **) 0);/* Unsave it */
  /* Check to see if we have an extended header to skip over also */
  if (head->header.isextended)
    isextended = 1;

  /* Skip past the header in the archive */
  userec (head);

  /*
 	 * If we needed to skip any extended headers, do so now, by
 	 * reading extended headers and skipping past them in the
	 * archive.
	 */
  if (isextended)
    {
      /*		register union record *exhdr;

		for (;;) {
			exhdr = findrec();

			if (!exhdr->ext_hdr.isextended) {
				userec(exhdr);
				break;
			}
			userec(exhdr);
		}*/
      skip_extended_headers ();
    }

  if (f_multivol)
    save_name = current_file_name;
  /* Skip to the next header on the archive */

  skip_file ((long) hstat.st_size);

  if (f_multivol)
    save_name = 0;
}


/*
 * Read a record that's supposed to be a header record.
 * Return its address in "head", and if it is good, the file's
 * size in hstat.st_size.
 *
 * Return 1 for success, 0 if the checksum is bad, EOF on eof,
 * 2 for a record full of zeros (EOF marker).
 *
 * You must always userec(head) to skip past the header which this
 * routine reads.
 */
int
read_header ()
{
  register int i;
  register long sum, signed_sum, recsum;
  register char *p;
  register union record *header;
  long from_oct ();
  char **longp;
  char *bp, *data;
  int size, written;
  static char *next_long_name, *next_long_link;
  char *name;

recurse:

  header = findrec ();
  head = header;		/* This is our current header */
  if (NULL == header)
    return EOF;

  recsum = from_oct (8, header->header.chksum);

  signed_sum = sum = 0;
  p = header->charptr;
  for (i = sizeof (*header); --i >= 0;)
    {
      /*
		 * We can't use unsigned char here because of old compilers,
		 * e.g. V7.
		 */
      signed_sum += *p;
      sum += 0xFF & *p++;
    }

  /* Adjust checksum to count the "chksum" field as blanks. */
  for (i = sizeof (header->header.chksum); --i >= 0;)
    {
      sum -= 0xFF & header->header.chksum[i];
      signed_sum -= (char) header->header.chksum[i];
    }
  sum += ' ' * sizeof header->header.chksum;
  signed_sum += ' ' * sizeof header->header.chksum;

  if (sum == 8 * ' ')
    {
      /*
		 * This is a zeroed record...whole record is 0's except
		 * for the 8 blanks we faked for the checksum field.
		 */
      return 2;
    }

  if (sum != recsum && signed_sum != recsum)
    return 0;

  /*
	 * Good record.  Decode file size and return.
	 */
  if (header->header.linkflag == LF_LINK)
    hstat.st_size = 0;		/* Links 0 size on tape */
  else
    hstat.st_size = from_oct (1 + 12, header->header.size);

  header->header.arch_name[NAMSIZ - 1] = '\0';
  if (header->header.linkflag == LF_LONGNAME
      || header->header.linkflag == LF_LONGLINK)
    {
      longp = ((header->header.linkflag == LF_LONGNAME)
	       ? &next_long_name
	       : &next_long_link);

      userec (header);
      if (*longp)
	free (*longp);
      bp = *longp = (char *) ck_malloc (hstat.st_size);

      for (size = hstat.st_size;
	   size > 0;
	   size -= written)
	{
	  data = findrec ()->charptr;
	  if (data == NULL)
	    {
	      msg ("Unexpected EOF on archive file");
	      break;
	    }
	  written = endofrecs ()->charptr - data;
	  if (written > size)
	    written = size;

	  bcopy (data, bp, written);
	  bp += written;
	  userec ((union record *) (data + written - 1));
	}
      goto recurse;
    }
  else
    {
      name = (next_long_name
	      ? next_long_name
	      : head->header.arch_name);
      if (current_file_name)
	free (current_file_name);
      current_file_name = ck_malloc (strlen (name) + 1);
      strcpy (current_file_name, name);

      name = (next_long_link
	      ? next_long_link
	      : head->header.arch_linkname);
      if (current_link_name)
	free (current_link_name);
      current_link_name = ck_malloc (strlen (name) + 1);
      strcpy (current_link_name, name);

      next_long_link = next_long_name = 0;
      return 1;
    }
}


/*
 * Decode things from a file header record into a "struct stat".
 * Also set "*stdp" to !=0 or ==0 depending whether header record is "Unix
 * Standard" tar format or regular old tar format.
 *
 * read_header() has already decoded the checksum and length, so we don't.
 *
 * If wantug != 0, we want the uid/group info decoded from Unix Standard
 * tapes (for extraction).  If == 0, we are just printing anyway, so save time.
 *
 * decode_header should NOT be called twice for the same record, since the
 * two calls might use different "wantug" values and thus might end up with
 * different uid/gid for the two calls.  If anybody wants the uid/gid they
 * should decode it first, and other callers should decode it without uid/gid
 * before calling a routine, e.g. print_header, that assumes decoded data.
 */
void
decode_header (header, st, stdp, wantug)
     register union record *header;
     register struct stat *st;
     int *stdp;
     int wantug;
{
  long from_oct ();

  st->st_mode = from_oct (8, header->header.mode);
  st->st_mode &= 07777;
  st->st_mtime = from_oct (1 + 12, header->header.mtime);
  if (f_gnudump)
    {
      st->st_atime = from_oct (1 + 12, header->header.atime);
      st->st_ctime = from_oct (1 + 12, header->header.ctime);
    }

  if (0 == strcmp (header->header.magic, TMAGIC))
    {
      /* Unix Standard tar archive */
      *stdp = 1;
      if (wantug)
	{
#ifdef NONAMES
	  st->st_uid = from_oct (8, header->header.uid);
	  st->st_gid = from_oct (8, header->header.gid);
#else
	  st->st_uid =
	    (*header->header.uname
	     ? finduid (header->header.uname)
	     : from_oct (8, header->header.uid));
	  st->st_gid =
	    (*header->header.gname
	     ? findgid (header->header.gname)
	     : from_oct (8, header->header.gid));
#endif
	}
#if defined(S_IFBLK) || defined(S_IFCHR)
      switch (header->header.linkflag)
	{
	case LF_BLK:
	case LF_CHR:
	  st->st_rdev = makedev (from_oct (8, header->header.devmajor),
				 from_oct (8, header->header.devminor));
	}
#endif
    }
  else
    {
      /* Old fashioned tar archive */
      *stdp = 0;
      st->st_uid = from_oct (8, header->header.uid);
      st->st_gid = from_oct (8, header->header.gid);
      st->st_rdev = 0;
    }
}


/*
 * Quick and dirty octal conversion.
 *
 * Result is -1 if the field is invalid (all blank, or nonoctal).
 */
long
from_oct (digs, where)
     register int digs;
     register char *where;
{
  register long value;

  while (isspace ((unsigned char) *where))
    {				/* Skip spaces */
      where++;
      if (--digs <= 0)
	return -1;		/* All blank field */
    }
  value = 0;
  while (digs > 0 && isodigit (*where))
    {				/* Scan til nonoctal */
      value = (value << 3) | (*where++ - '0');
      --digs;
    }

  if (digs > 0 && *where && !isspace ((unsigned char) *where))
    return -1;			/* Ended on non-space/nul */

  return value;
}


/*
 * Actually print it.
 *
 * Plain and fancy file header block logging.
 * Non-verbose just prints the name, e.g. for "tar t" or "tar x".
 * This should just contain file names, so it can be fed back into tar
 * with xargs or the "-T" option.  The verbose option can give a bunch
 * of info, one line per file.  I doubt anybody tries to parse its
 * format, or if they do, they shouldn't.  Unix tar is pretty random here
 * anyway.
 *
 * Note that print_header uses the globals <head>, <hstat>, and
 * <head_standard>, which must be set up in advance.  This is not very clean
 * and should be cleaned up.  FIXME.
 */
#define	UGSWIDTH	18	/* min width of User, group, size */
/* UGSWIDTH of 18 means that with user and group names <= 8 chars the columns
   never shift during the listing.  */
#define	DATEWIDTH	19	/* Last mod date */
static int ugswidth = UGSWIDTH;	/* Max width encountered so far */

void
print_header ()
{
  char modes[11];
  char timestamp[80];
  char uform[11], gform[11];	/* These hold formatted ints */
  char *user, *group;
  char size[24];		/* Holds a formatted long or maj, min */
  time_t longie;
  int pad;
  char *name;
  extern long baserec;

  if (f_sayblock)
    fprintf (msg_file, "rec %10d: ", baserec + (ar_record - ar_block));
  /* annofile(msg_file, (char *)NULL); */

  if (f_verbose <= 1)
    {
      /* Just the fax, mam. */
      char *name;

      name = quote_copy_string (current_file_name);
      if (name == 0)
	name = current_file_name;
      fprintf (msg_file, "%s\n", name);
      if (name != current_file_name)
	free (name);
    }
  else
    {
      /* File type and modes */
      modes[0] = '?';
      switch (head->header.linkflag)
	{
	case LF_VOLHDR:
	  modes[0] = 'V';
	  break;

	case LF_MULTIVOL:
	  modes[0] = 'M';
	  break;

	case LF_NAMES:
	  modes[0] = 'N';
	  break;

	case LF_LONGNAME:
	case LF_LONGLINK:
	  msg ("Visible longname error\n");
	  break;

	case LF_SPARSE:
	case LF_NORMAL:
	case LF_OLDNORMAL:
	case LF_LINK:
	  modes[0] = '-';
	  if ('/' == current_file_name[strlen (current_file_name) - 1])
	    modes[0] = 'd';
	  break;
	case LF_DUMPDIR:
	  modes[0] = 'd';
	  break;
	case LF_DIR:
	  modes[0] = 'd';
	  break;
	case LF_SYMLINK:
	  modes[0] = 'l';
	  break;
	case LF_BLK:
	  modes[0] = 'b';
	  break;
	case LF_CHR:
	  modes[0] = 'c';
	  break;
	case LF_FIFO:
	  modes[0] = 'p';
	  break;
	case LF_CONTIG:
	  modes[0] = 'C';
	  break;
	}

      demode ((unsigned) hstat.st_mode, modes + 1);

      /* Timestamp */
      longie = hstat.st_mtime;
      strftime(timestamp, sizeof(timestamp), "%c", localtime(&longie));
      timestamp[16] = '\0';
      timestamp[24] = '\0';

      /* User and group names */
      if (*head->header.uname && head_standard)
	{
	  user = head->header.uname;
	}
      else
	{
	  user = uform;
	  (void) sprintf (uform, "%d",
			  from_oct (8, head->header.uid));
	}
      if (*head->header.gname && head_standard)
	{
	  group = head->header.gname;
	}
      else
	{
	  group = gform;
	  (void) sprintf (gform, "%d",
			  from_oct (8, head->header.gid));
	}

      /* Format the file size or major/minor device numbers */
      switch (head->header.linkflag)
	{
#if defined(S_IFBLK) || defined(S_IFCHR)
	case LF_CHR:
	case LF_BLK:
	  (void) sprintf (size, "%d,%d",
			  major (hstat.st_rdev),
			  minor (hstat.st_rdev));
	  break;
#endif
	case LF_SPARSE:
	  (void) sprintf (size, "%ld",
			  from_oct (1 + 12, head->header.realsize));
	  break;
	default:
	  (void) sprintf (size, "%ld", (long) hstat.st_size);
	}

      /* Figure out padding and print the whole line. */
      pad = strlen (user) + strlen (group) + strlen (size) + 1;
      if (pad > ugswidth)
	ugswidth = pad;

      name = quote_copy_string (current_file_name);
      if (!name)
	name = current_file_name;
      fprintf (msg_file, "%s %s/%s %*s%s %s %s %s",
	       modes,
	       user,
	       group,
	       ugswidth - pad,
	       "",
	       size,
	       timestamp + 4, timestamp + 20,
	       name);

      if (name != current_file_name)
	free (name);
      switch (head->header.linkflag)
	{
	case LF_SYMLINK:
	  name = quote_copy_string (current_link_name);
	  if (!name)
	    name = current_link_name;
	  fprintf (msg_file, " -> %s\n", name);
	  if (name != current_link_name)
	    free (name);
	  break;

	case LF_LINK:
	  name = quote_copy_string (current_link_name);
	  if (!name)
	    name = current_link_name;
	  fprintf (msg_file, " link to %s\n", current_link_name);
	  if (name != current_link_name)
	    free (name);
	  break;

	default:
	  fprintf (msg_file, " unknown file type '%c'\n",
		   head->header.linkflag);
	  break;

	case LF_OLDNORMAL:
	case LF_NORMAL:
	case LF_SPARSE:
	case LF_CHR:
	case LF_BLK:
	case LF_DIR:
	case LF_FIFO:
	case LF_CONTIG:
	case LF_DUMPDIR:
	  putc ('\n', msg_file);
	  break;

	case LF_VOLHDR:
	  fprintf (msg_file, "--Volume Header--\n");
	  break;

	case LF_MULTIVOL:
	  fprintf (msg_file, "--Continued at byte %ld--\n", from_oct (1 + 12, head->header.offset));
	  break;

	case LF_NAMES:
	  fprintf (msg_file, "--Mangled file names--\n");
	  break;
	}
    }
  fflush (msg_file);
}

/*
 * Print a similar line when we make a directory automatically.
 */
void
pr_mkdir (pathname, length, mode)
     char *pathname;
     int length;
     int mode;
{
  char modes[11];
  char *name;
  extern long baserec;

  if (f_verbose > 1)
    {
      /* File type and modes */
      modes[0] = 'd';
      demode ((unsigned) mode, modes + 1);

      if (f_sayblock)
	fprintf (msg_file, "rec %10d: ", baserec + (ar_record - ar_block));
      /* annofile(msg_file, (char *)NULL); */
      name = quote_copy_string (pathname);
      if (!name)
	name = pathname;
      fprintf (msg_file, "%s %*s %.*s\n",
	       modes,
	       ugswidth + DATEWIDTH,
	       "Creating directory:",
	       length,
	       pathname);
      if (name != pathname)
	free (name);
    }
}


/*
 * Skip over <size> bytes of data in records in the archive.
 */
void
skip_file (size)
     register long size;
{
  union record *x;
  extern long save_totsize;
  extern long save_sizeleft;

  if (f_multivol)
    {
      save_totsize = size;
      save_sizeleft = size;
    }

  while (size > 0)
    {
      x = findrec ();
      if (x == NULL)
	{			/* Check it... */
	  msg ("Unexpected EOF on archive file");
	  exit (EX_BADARCH);
	}
      userec (x);
      size -= RECORDSIZE;
      if (f_multivol)
	save_sizeleft -= RECORDSIZE;
    }
}

void
skip_extended_headers ()
{
  register union record *exhdr;

  for (;;)
    {
      exhdr = findrec ();
      if (!exhdr->ext_hdr.isextended)
	{
	  userec (exhdr);
	  break;
	}
      userec (exhdr);
    }
}

/*
 * Decode the mode string from a stat entry into a 9-char string and a null.
 */
void
demode (mode, string)
     register unsigned mode;
     register char *string;
{
  register unsigned mask;
  register char *rwx = "rwxrwxrwx";

  for (mask = 0400; mask != 0; mask >>= 1)
    {
      if (mode & mask)
	*string++ = *rwx++;
      else
	{
	  *string++ = '-';
	  rwx++;
	}
    }

  if (mode & S_ISUID)
    if (string[-7] == 'x')
      string[-7] = 's';
    else
      string[-7] = 'S';
  if (mode & S_ISGID)
    if (string[-4] == 'x')
      string[-4] = 's';
    else
      string[-4] = 'S';
  if (mode & S_ISVTX)
    if (string[-1] == 'x')
      string[-1] = 't';
    else
      string[-1] = 'T';
  *string = '\0';
}