*** empty log message ***

[chaz/tar] / src / list.c

/* List a tar archive.
   Copyright (C) 1988, 1992 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 */

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();
                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, 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;

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

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

        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.
                 */
                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];
        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) 
          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
          {
            current_file_name = (next_long_name
                                 ? next_long_name
                                 : header->header.arch_name);
            current_link_name = (next_long_link
                                 ? next_long_link
                                 : header->header.arch_linkname);
            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();
        char **longp;
        char *bp, *data;
        int size, written;

        st->st_mode = from_oct(8,  header->header.mode);
        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(*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(*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;
        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;          /* To make ctime() call portable */
        int     pad;
        char *name;
        extern long baserec;
        static char *longname;
        static char *longlink;
        int bumplongs;

        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;
                timestamp = ctime(&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';
}