blob: 9b0b6ae9877e986c9f32c8d6c2b3a518c16de00d [file] [log] [blame]
/* copyin.c - extract or list a cpio archive
Copyright (C) 1990,1991,1992,2001,2002,2003,2004 Free Software Foundation, Inc.
This program 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.
This program 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, write to the Free Software Foundation, Inc.,
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <malloc.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>
#include <utime.h>
#include <fnmatch.h>
# ifndef DIRECTORY_SEPARATOR
# define DIRECTORY_SEPARATOR '/'
# endif
# ifndef ISSLASH
# define ISSLASH(C) ((C) == DIRECTORY_SEPARATOR)
# endif
/* Return 1 if an array of N objects, each of size S, cannot exist due
to size arithmetic overflow. S must be positive and N must be
nonnegative. This is a macro, not an inline function, so that it
works correctly even when SIZE_MAX < N.
By gnulib convention, SIZE_MAX represents overflow in size
calculations, so the conservative dividend to use here is
SIZE_MAX - 1, since SIZE_MAX might represent an overflowed value.
However, malloc (SIZE_MAX) fails on all known hosts where
sizeof (ptrdiff_t) <= sizeof (size_t), so do not bother to test for
exactly-SIZE_MAX allocations on such hosts; this avoids a test and
branch when S is known to be 1. */
# define xalloc_oversized(n, s) \
((size_t) (sizeof (ptrdiff_t) <= sizeof (size_t) ? -1 : -2) / (s) < (n))
#define DISK_IO_BLOCK_SIZE (512)
char *progname = NULL;
/* If true, print a . for each file processed. (-V) */
char dot_flag = false;
/* Input and output buffers. */
char *input_buffer, *output_buffer;
/* The size of the input buffer. */
long input_buffer_size;
/* Current locations in `input_buffer' and `output_buffer'. */
char *in_buff, *out_buff;
/* Current number of bytes stored at `input_buff' and `output_buff'. */
long input_size, output_size;
/* Block size value, initially 512. -B sets to 5120. */
int io_block_size = 512;
struct new_cpio_header {
unsigned short c_magic;
union {
struct {
unsigned long c_ino;
unsigned long c_mode;
unsigned long c_uid;
unsigned long c_gid;
unsigned long c_nlink;
unsigned long c_mtime;
unsigned long c_filesize;
long c_dev_maj;
long c_dev_min;
long c_rdev_maj;
long c_rdev_min;
unsigned long c_namesize;
unsigned long c_chksum;
};
unsigned long c_hdr[13];
};
char *c_name;
char *c_tar_linkname;
};
/* Total number of bytes read and written for all files.
* Now that many tape drives hold more than 4Gb we need more than 32
* bits to hold input_bytes and output_bytes.
*/
long long input_bytes, output_bytes;
/* Allocate N bytes of memory dynamically, with error checking. */
static void *xmalloc(size_t n)
{
void *p;
if (xalloc_oversized(n, 1) || (!(p = malloc(n)) && n != 0)) {
fprintf(stderr, "%s: memory exhausted\n", progname);
exit(1);
}
return p;
/* return xnmalloc_inline (n, 1); */
}
/* Clone STRING. */
static char *xstrdup(char const *string)
{
size_t s = strlen(string) + 1;
return memcpy(xmalloc(s), string, s);
/* return xmemdup_inline (string, strlen (string) + 1); */
}
/* Copy NUM_BYTES of buffer `in_buff' into IN_BUF.
`in_buff' may be partly full.
When `in_buff' is exhausted, refill it from file descriptor IN_DES. */
static void tape_fill_input_buffer(int in_des, int num_bytes)
{
in_buff = input_buffer;
num_bytes = (num_bytes < io_block_size) ? num_bytes : io_block_size;
input_size = read(in_des, input_buffer, num_bytes);
if (input_size < 0) {
fprintf(stderr, "%s: read error: %s\n", progname,
strerror(errno));
exit(1);
}
if (input_size == 0) {
fprintf(stderr, "%s: premature end of file\n", progname);
exit(1);
}
input_bytes += input_size;
}
/* Write `output_size' bytes of `output_buffer' to file
descriptor OUT_DES and reset `output_size' and `out_buff'.
If `swapping_halfwords' or `swapping_bytes' is set,
do the appropriate swapping first. Our callers have
to make sure to only set these flags if `output_size'
is appropriate (a multiple of 4 for `swapping_halfwords',
2 for `swapping_bytes'). The fact that DISK_IO_BLOCK_SIZE
must always be a multiple of 4 helps us (and our callers)
insure this. */
static void disk_empty_output_buffer(int out_des)
{
int bytes_written;
bytes_written = write(out_des, output_buffer, output_size);
if (bytes_written != output_size) {
fprintf(stderr, "%s: write error: %s\n",
progname, strerror(errno));
exit(1);
}
output_bytes += output_size;
out_buff = output_buffer;
output_size = 0;
}
/* Copy NUM_BYTES of buffer IN_BUF to `out_buff', which may be partly full.
When `out_buff' fills up, flush it to file descriptor OUT_DES. */
static void disk_buffered_write(char *in_buf, int out_des, long num_bytes)
{
register long bytes_left = num_bytes; /* Bytes needing to be copied. */
register long space_left; /* Room left in output buffer. */
while (bytes_left > 0) {
space_left = DISK_IO_BLOCK_SIZE - output_size;
if (space_left == 0)
disk_empty_output_buffer(out_des);
else {
if (bytes_left < space_left)
space_left = bytes_left;
memmove(out_buff, in_buf, (unsigned)space_left);
out_buff += space_left;
output_size += space_left;
in_buf += space_left;
bytes_left -= space_left;
}
}
}
/* Copy a file using the input and output buffers, which may start out
partly full. After the copy, the files are not closed nor the last
block flushed to output, and the input buffer may still be partly
full. If `crc_i_flag' is set, add each byte to `crc'.
IN_DES is the file descriptor for input;
OUT_DES is the file descriptor for output;
NUM_BYTES is the number of bytes to copy. */
static void copy_files_tape_to_disk(int in_des, int out_des, long num_bytes)
{
long size;
while (num_bytes > 0) {
if (input_size == 0)
tape_fill_input_buffer(in_des, io_block_size);
size = (input_size < num_bytes) ? input_size : num_bytes;
disk_buffered_write(in_buff, out_des, size);
num_bytes -= size;
input_size -= size;
in_buff += size;
}
}
/* if IN_BUF is NULL, Skip the next NUM_BYTES bytes of file descriptor IN_DES. */
static void tape_buffered_read(char *in_buf, int in_des, long num_bytes)
{
register long bytes_left = num_bytes; /* Bytes needing to be copied. */
register long space_left; /* Bytes to copy from input buffer. */
while (bytes_left > 0) {
if (input_size == 0)
tape_fill_input_buffer(in_des, io_block_size);
if (bytes_left < input_size)
space_left = bytes_left;
else
space_left = input_size;
if (in_buf != NULL) {
memmove(in_buf, in_buff, (unsigned)space_left);
in_buf += space_left;
}
in_buff += space_left;
input_size -= space_left;
bytes_left -= space_left;
}
}
/* Skip the next NUM_BYTES bytes of file descriptor IN_DES. */
#define tape_toss_input(in_des,num_bytes) \
(tape_buffered_read(NULL,(in_des),(num_bytes)))
struct deferment {
struct deferment *next;
struct new_cpio_header header;
};
static struct deferment *create_deferment(struct new_cpio_header *file_hdr)
{
struct deferment *d;
d = (struct deferment *)xmalloc(sizeof(struct deferment));
d->header = *file_hdr;
d->header.c_name = (char *)xmalloc(strlen(file_hdr->c_name) + 1);
strcpy(d->header.c_name, file_hdr->c_name);
return d;
}
static void free_deferment(struct deferment *d)
{
free(d->header.c_name);
free(d);
}
static int link_to_name(char *link_name, char *link_target)
{
int res = link(link_target, link_name);
return res;
}
struct inode_val {
unsigned long inode;
unsigned long major_num;
unsigned long minor_num;
char *file_name;
};
/* Inode hash table. Allocated by first call to add_inode. */
static struct inode_val **hash_table = NULL;
/* Size of current hash table. Initial size is 47. (47 = 2*22 + 3) */
static int hash_size = 22;
/* Number of elements in current hash table. */
static int hash_num;
/* Do the hash insert. Used in normal inserts and resizing the hash
table. It is guaranteed that there is room to insert the item.
NEW_VALUE is the pointer to the previously allocated inode, file
name association record. */
static void hash_insert(struct inode_val *new_value)
{
int start; /* Home position for the value. */
int temp; /* Used for rehashing. */
/* Hash function is node number modulo the table size. */
start = new_value->inode % hash_size;
/* Do the initial look into the table. */
if (hash_table[start] == NULL) {
hash_table[start] = new_value;
return;
}
/* If we get to here, the home position is full with a different inode
record. Do a linear search for the first NULL pointer and insert
the new item there. */
temp = (start + 1) % hash_size;
while (hash_table[temp] != NULL)
temp = (temp + 1) % hash_size;
/* Insert at the NULL. */
hash_table[temp] = new_value;
}
/* Associate FILE_NAME with the inode NODE_NUM. (Insert into hash table.) */
static void
add_inode(unsigned long node_num, char *file_name, unsigned long major_num,
unsigned long minor_num)
{
struct inode_val *temp;
/* Create new inode record. */
temp = (struct inode_val *)xmalloc(sizeof(struct inode_val));
temp->inode = node_num;
temp->major_num = major_num;
temp->minor_num = minor_num;
temp->file_name = xstrdup(file_name);
/* Do we have to increase the size of (or initially allocate)
the hash table? */
if (hash_num == hash_size || hash_table == NULL) {
struct inode_val **old_table; /* Pointer to old table. */
int i; /* Index for re-insert loop. */
/* Save old table. */
old_table = hash_table;
if (old_table == NULL)
hash_num = 0;
/* Calculate new size of table and allocate it.
Sequence of table sizes is 47, 97, 197, 397, 797, 1597, 3197, 6397 ...
where 3197 and most of the sizes after 6397 are not prime. The other
numbers listed are prime. */
hash_size = 2 * hash_size + 3;
hash_table = (struct inode_val **)
xmalloc(hash_size * sizeof(struct inode_val *));
memset(hash_table, 0, hash_size * sizeof(struct inode_val *));
/* Insert the values from the old table into the new table. */
for (i = 0; i < hash_num; i++)
hash_insert(old_table[i]);
free(old_table);
}
/* Insert the new record and increment the count of elements in the
hash table. */
hash_insert(temp);
hash_num++;
}
static char *find_inode_file(unsigned long node_num, unsigned long major_num,
unsigned long minor_num)
{
int start; /* Initial hash location. */
int temp; /* Rehash search variable. */
if (hash_table != NULL) {
/* Hash function is node number modulo the table size. */
start = node_num % hash_size;
/* Initial look into the table. */
if (hash_table[start] == NULL)
return NULL;
if (hash_table[start]->inode == node_num
&& hash_table[start]->major_num == major_num
&& hash_table[start]->minor_num == minor_num)
return hash_table[start]->file_name;
/* The home position is full with a different inode record.
Do a linear search terminated by a NULL pointer. */
for (temp = (start + 1) % hash_size;
hash_table[temp] != NULL && temp != start;
temp = (temp + 1) % hash_size) {
if (hash_table[temp]->inode == node_num
&& hash_table[start]->major_num == major_num
&& hash_table[start]->minor_num == minor_num)
return hash_table[temp]->file_name;
}
}
return NULL;
}
/* Try and create a hard link from FILE_NAME to another file
with the given major/minor device number and inode. If no other
file with the same major/minor/inode numbers is known, add this file
to the list of known files and associated major/minor/inode numbers
and return -1. If another file with the same major/minor/inode
numbers is found, try and create another link to it using
link_to_name, and return 0 for success and -1 for failure. */
static int
link_to_maj_min_ino(char *file_name, int st_dev_maj, int st_dev_min, int st_ino)
{
int link_res;
char *link_name;
link_res = -1;
/* Is the file a link to a previously copied file? */
link_name = find_inode_file(st_ino, st_dev_maj, st_dev_min);
if (link_name == NULL)
add_inode(st_ino, file_name, st_dev_maj, st_dev_min);
else
link_res = link_to_name(file_name, link_name);
return link_res;
}
static void copyin_regular_file(struct new_cpio_header *file_hdr,
int in_file_des);
static void warn_junk_bytes(long bytes_skipped)
{
fprintf(stderr, "%s: warning: skipped %ld byte(s) of junk\n",
progname, bytes_skipped);
}
/* Skip the padding on IN_FILE_DES after a header or file,
up to the next header.
The number of bytes skipped is based on OFFSET -- the current offset
from the last start of a header (or file) -- and the current
header type. */
static void tape_skip_padding(int in_file_des, int offset)
{
int pad;
pad = (4 - (offset % 4)) % 4;
if (pad != 0)
tape_toss_input(in_file_des, pad);
}
static int
try_existing_file(struct new_cpio_header *file_hdr, int in_file_des,
int *existing_dir)
{
struct stat file_stat;
*existing_dir = false;
if (lstat(file_hdr->c_name, &file_stat) == 0) {
if (S_ISDIR(file_stat.st_mode)
&& ((file_hdr->c_mode & S_IFMT) == S_IFDIR)) {
/* If there is already a directory there that
we are trying to create, don't complain about
it. */
*existing_dir = true;
return 0;
} else if (S_ISDIR(file_stat.st_mode)
? rmdir(file_hdr->c_name)
: unlink(file_hdr->c_name)) {
fprintf(stderr, "%s: cannot remove current %s: %s\n",
progname, file_hdr->c_name, strerror(errno));
tape_toss_input(in_file_des, file_hdr->c_filesize);
tape_skip_padding(in_file_des, file_hdr->c_filesize);
return -1; /* Go to the next file. */
}
}
return 0;
}
/* The newc and crc formats store multiply linked copies of the same file
in the archive only once. The actual data is attached to the last link
in the archive, and the other links all have a filesize of 0. When a
file in the archive has multiple links and a filesize of 0, its data is
probably "attatched" to another file in the archive, so we can't create
it right away. We have to "defer" creating it until we have created
the file that has the data "attatched" to it. We keep a list of the
"defered" links on deferments. */
struct deferment *deferments = NULL;
/* Add a file header to the deferments list. For now they all just
go on one list, although we could optimize this if necessary. */
static void defer_copyin(struct new_cpio_header *file_hdr)
{
struct deferment *d;
d = create_deferment(file_hdr);
d->next = deferments;
deferments = d;
return;
}
/* We just created a file that (probably) has some other links to it
which have been defered. Go through all of the links on the deferments
list and create any which are links to this file. */
static void create_defered_links(struct new_cpio_header *file_hdr)
{
struct deferment *d;
struct deferment *d_prev;
int ino;
int maj;
int min;
int link_res;
ino = file_hdr->c_ino;
maj = file_hdr->c_dev_maj;
min = file_hdr->c_dev_min;
d = deferments;
d_prev = NULL;
while (d != NULL) {
if ((d->header.c_ino == ino) && (d->header.c_dev_maj == maj)
&& (d->header.c_dev_min == min)) {
struct deferment *d_free;
link_res =
link_to_name(d->header.c_name, file_hdr->c_name);
if (link_res < 0) {
fprintf(stderr,
"%s: cannot link %s to %s: %s\n",
progname, d->header.c_name,
file_hdr->c_name, strerror(errno));
}
if (d_prev != NULL)
d_prev->next = d->next;
else
deferments = d->next;
d_free = d;
d = d->next;
free_deferment(d_free);
} else {
d_prev = d;
d = d->next;
}
}
}
/* If we had a multiply linked file that really was empty then we would
have defered all of its links, since we never found any with data
"attached", and they will still be on the deferment list even when
we are done reading the whole archive. Write out all of these
empty links that are still on the deferments list. */
static void create_final_defers(void)
{
struct deferment *d;
int link_res;
int out_file_des;
struct utimbuf times; /* For setting file times. */
/* Initialize this in case it has members we don't know to set. */
memset(&times, 0, sizeof(struct utimbuf));
for (d = deferments; d != NULL; d = d->next) {
/* Debian hack: A line, which could cause an endless loop, was
removed (97/1/2). It was reported by Ronald F. Guilmette to
the upstream maintainers. -BEM */
/* Debian hack: This was reported by Horst Knobloch. This bug has
been reported to "bug-gnu-utils@prep.ai.mit.edu". (99/1/6) -BEM
*/
link_res = link_to_maj_min_ino(d->header.c_name,
d->header.c_dev_maj,
d->header.c_dev_min,
d->header.c_ino);
if (link_res == 0) {
continue;
}
out_file_des = open(d->header.c_name, O_CREAT | O_WRONLY, 0600);
if (out_file_des < 0) {
fprintf(stderr, "%s: open %s: %s\n",
progname, d->header.c_name, strerror(errno));
continue;
}
/* File is now copied; set attributes. */
if ((fchown(out_file_des, d->header.c_uid, d->header.c_gid) < 0)
&& errno != EPERM)
fprintf(stderr, "%s: fchown %s: %s\n",
progname, d->header.c_name, strerror(errno));
/* chown may have turned off some permissions we wanted. */
if (fchmod(out_file_des, (int)d->header.c_mode) < 0)
fprintf(stderr, "%s: fchmod %s: %s\n",
progname, d->header.c_name, strerror(errno));
if (close(out_file_des) < 0)
fprintf(stderr, "%s: close %s: %s\n",
progname, d->header.c_name, strerror(errno));
}
}
static void
copyin_regular_file(struct new_cpio_header *file_hdr, int in_file_des)
{
int out_file_des; /* Output file descriptor. */
/* Can the current file be linked to a previously copied file? */
if (file_hdr->c_nlink > 1) {
int link_res;
if (file_hdr->c_filesize == 0) {
/* The newc and crc formats store multiply linked copies
of the same file in the archive only once. The
actual data is attached to the last link in the
archive, and the other links all have a filesize
of 0. Since this file has multiple links and a
filesize of 0, its data is probably attatched to
another file in the archive. Save the link, and
process it later when we get the actual data. We
can't just create it with length 0 and add the
data later, in case the file is readonly. We still
lose if its parent directory is readonly (and we aren't
running as root), but there's nothing we can do about
that. */
defer_copyin(file_hdr);
tape_toss_input(in_file_des, file_hdr->c_filesize);
tape_skip_padding(in_file_des, file_hdr->c_filesize);
return;
}
/* If the file has data (filesize != 0), then presumably
any other links have already been defer_copyin'ed(),
but GNU cpio version 2.0-2.2 didn't do that, so we
still have to check for links here (and also in case
the archive was created and later appeneded to). */
/* Debian hack: (97/1/2) This was reported by Ronald
F. Guilmette to the upstream maintainers. -BEM */
link_res = link_to_maj_min_ino(file_hdr->c_name,
file_hdr->c_dev_maj,
file_hdr->c_dev_min,
file_hdr->c_ino);
if (link_res == 0) {
tape_toss_input(in_file_des, file_hdr->c_filesize);
tape_skip_padding(in_file_des, file_hdr->c_filesize);
return;
}
}
/* If not linked, copy the contents of the file. */
out_file_des = open(file_hdr->c_name, O_CREAT | O_WRONLY, 0600);
if (out_file_des < 0) {
fprintf(stderr, "%s: open %s: %s\n",
progname, file_hdr->c_name, strerror(errno));
tape_toss_input(in_file_des, file_hdr->c_filesize);
tape_skip_padding(in_file_des, file_hdr->c_filesize);
return;
}
copy_files_tape_to_disk(in_file_des, out_file_des,
file_hdr->c_filesize);
disk_empty_output_buffer(out_file_des);
if (close(out_file_des) < 0)
fprintf(stderr, "%s: close %s: %s\n",
progname, file_hdr->c_name, strerror(errno));
/* File is now copied; set attributes. */
if ((chown(file_hdr->c_name, file_hdr->c_uid, file_hdr->c_gid) < 0)
&& errno != EPERM)
fprintf(stderr, "%s: chown %s: %s\n",
progname, file_hdr->c_name, strerror(errno));
/* chown may have turned off some permissions we wanted. */
if (chmod(file_hdr->c_name, (int)file_hdr->c_mode) < 0)
fprintf(stderr, "%s: chmod %s: %s\n",
progname, file_hdr->c_name, strerror(errno));
tape_skip_padding(in_file_des, file_hdr->c_filesize);
if (file_hdr->c_nlink > 1) {
/* (see comment above for how the newc and crc formats
store multiple links). Now that we have the data
for this file, create any other links to it which
we defered. */
create_defered_links(file_hdr);
}
}
/* In general, we can't use the builtin `basename' function if available,
since it has different meanings in different environments.
In some environments the builtin `basename' modifies its argument.
Return the address of the last file name component of NAME. If
NAME has no file name components because it is all slashes, return
NAME if it is empty, the address of its last slash otherwise. */
static char *base_name(char const *name)
{
char const *base = name;
char const *p;
for (p = base; *p; p++) {
if (ISSLASH(*p)) {
/* Treat multiple adjacent slashes like a single slash. */
do
p++;
while (ISSLASH(*p));
/* If the file name ends in slash, use the trailing slash as
the basename if no non-slashes have been found. */
if (!*p) {
if (ISSLASH(*base))
base = p - 1;
break;
}
/* *P is a non-slash preceded by a slash. */
base = p;
}
}
return (char *)base;
}
/* Return the length of of the basename NAME. Typically NAME is the
value returned by base_name. Act like strlen (NAME), except omit
redundant trailing slashes. */
static size_t base_len(char const *name)
{
size_t len;
for (len = strlen(name); 1 < len && ISSLASH(name[len - 1]); len--)
continue;
return len;
}
/* Remove trailing slashes from PATH.
Return true if a trailing slash was removed.
This is useful when using filename completion from a shell that
adds a "/" after directory names (such as tcsh and bash), because
the Unix rename and rmdir system calls return an "Invalid argument" error
when given a path that ends in "/" (except for the root directory). */
static bool strip_trailing_slashes(char *path)
{
char *base = base_name(path);
char *base_lim = base + base_len(base);
bool had_slash = (*base_lim != '\0');
*base_lim = '\0';
return had_slash;
}
static void copyin_directory(struct new_cpio_header *file_hdr, int existing_dir)
{
int res; /* Result of various function calls. */
/* Strip any trailing `/'s off the filename; tar puts
them on. We might as well do it here in case anybody
else does too, since they cause strange things to happen. */
strip_trailing_slashes(file_hdr->c_name);
/* Ignore the current directory. It must already exist,
and we don't want to change its permission, ownership
or time. */
if (file_hdr->c_name[0] == '.' && file_hdr->c_name[1] == '\0') {
return;
}
if (!existing_dir)
{
res = mkdir(file_hdr->c_name, file_hdr->c_mode);
} else
res = 0;
if (res < 0) {
/* In some odd cases where the file_hdr->c_name includes `.',
the directory may have actually been created by
create_all_directories(), so the mkdir will fail
because the directory exists. If that's the case,
don't complain about it. */
struct stat file_stat;
if ((errno != EEXIST) ||
(lstat(file_hdr->c_name, &file_stat) != 0) ||
!(S_ISDIR(file_stat.st_mode))) {
fprintf(stderr, "%s: lstat %s: %s\n",
progname, file_hdr->c_name, strerror(errno));
return;
}
}
if ((chown(file_hdr->c_name, file_hdr->c_uid, file_hdr->c_gid) < 0)
&& errno != EPERM)
fprintf(stderr, "%s: chown %s: %s\n",
progname, file_hdr->c_name, strerror(errno));
/* chown may have turned off some permissions we wanted. */
if (chmod(file_hdr->c_name, (int)file_hdr->c_mode) < 0)
fprintf(stderr, "%s: chmod %s: %s\n",
progname, file_hdr->c_name, strerror(errno));
}
static void copyin_device(struct new_cpio_header *file_hdr)
{
int res; /* Result of various function calls. */
if (file_hdr->c_nlink > 1) {
int link_res;
/* Debian hack: This was reported by Horst
Knobloch. This bug has been reported to
"bug-gnu-utils@prep.ai.mit.edu". (99/1/6) -BEM */
link_res = link_to_maj_min_ino(file_hdr->c_name,
file_hdr->c_dev_maj,
file_hdr->c_dev_min,
file_hdr->c_ino);
if (link_res == 0) {
return;
}
}
res = mknod(file_hdr->c_name, file_hdr->c_mode,
makedev(file_hdr->c_rdev_maj, file_hdr->c_rdev_min));
if (res < 0) {
fprintf(stderr, "%s: mknod %s: %s\n", progname,
file_hdr->c_name, strerror(errno));
return;
}
if ((chown(file_hdr->c_name, file_hdr->c_uid, file_hdr->c_gid) < 0)
&& errno != EPERM)
fprintf(stderr, "%s: chown %s: %s\n", progname,
file_hdr->c_name, strerror(errno));
/* chown may have turned off some permissions we wanted. */
if (chmod(file_hdr->c_name, file_hdr->c_mode) < 0)
fprintf(stderr, "%s: chmod %s: %s\n", progname,
file_hdr->c_name, strerror(errno));
}
static void copyin_link(struct new_cpio_header *file_hdr, int in_file_des)
{
char *link_name = NULL; /* Name of hard and symbolic links. */
int res; /* Result of various function calls. */
link_name = (char *)xmalloc(file_hdr->c_filesize + 1);
link_name[file_hdr->c_filesize] = '\0';
tape_buffered_read(link_name, in_file_des, file_hdr->c_filesize);
tape_skip_padding(in_file_des, file_hdr->c_filesize);
res = symlink(link_name, file_hdr->c_name);
if (res < 0) {
fprintf(stderr, "%s: symlink %s: %s\n",
progname, file_hdr->c_name, strerror(errno));
free(link_name);
return;
}
if ((lchown(file_hdr->c_name, file_hdr->c_uid, file_hdr->c_gid) < 0)
&& errno != EPERM) {
fprintf(stderr, "%s: lchown %s: %s\n",
progname, file_hdr->c_name, strerror(errno));
}
free(link_name);
}
static void copyin_file(struct new_cpio_header *file_hdr, int in_file_des)
{
int existing_dir;
if (try_existing_file(file_hdr, in_file_des, &existing_dir) < 0)
return;
/* Do the real copy or link. */
switch (file_hdr->c_mode & S_IFMT) {
case S_IFREG:
copyin_regular_file(file_hdr, in_file_des);
break;
case S_IFDIR:
copyin_directory(file_hdr, existing_dir);
break;
case S_IFCHR:
case S_IFBLK:
case S_IFSOCK:
case S_IFIFO:
copyin_device(file_hdr);
break;
case S_IFLNK:
copyin_link(file_hdr, in_file_des);
break;
default:
fprintf(stderr, "%s: %s: unknown file type\n",
progname, file_hdr->c_name);
tape_toss_input(in_file_des, file_hdr->c_filesize);
tape_skip_padding(in_file_des, file_hdr->c_filesize);
}
}
/* Fill in FILE_HDR by reading a new-format ASCII format cpio header from
file descriptor IN_DES, except for the magic number, which is
already filled in. */
static void read_in_new_ascii(struct new_cpio_header *file_hdr, int in_des)
{
char ascii_header[13*8], *ah, hexbuf[9];
int i;
tape_buffered_read(ascii_header, in_des, 13*8);
ah = ascii_header;
hexbuf[8] = '\0';
for (i = 0; i < 13; i++) {
memcpy(hexbuf, ah, 8);
file_hdr->c_hdr[i] = strtoul(hexbuf, NULL, 16);
ah += 8;
}
/* Sizes > LONG_MAX can currently result in integer overflow
in various places. Fail if name is too large. */
if (file_hdr->c_namesize > LONG_MAX) {
fprintf(stderr, "%s: name size out of range\n",
progname);
exit(1);
}
/* Read file name from input. */
free(file_hdr->c_name);
file_hdr->c_name = (char *)xmalloc(file_hdr->c_namesize);
tape_buffered_read(file_hdr->c_name, in_des,
(long)file_hdr->c_namesize);
/* In SVR4 ASCII format, the amount of space allocated for the header
is rounded up to the next long-word, so we might need to drop
1-3 bytes. */
tape_skip_padding(in_des, file_hdr->c_namesize + 110);
/* Fail if file is too large. We could check this earlier
but it's helpful to report the name. */
if (file_hdr->c_filesize > LONG_MAX) {
fprintf(stderr, "%s: %s: file size out of range\n",
progname, file_hdr->c_name);
exit(1);
}
}
/* Return 16-bit integer I with the bytes swapped. */
#define swab_short(i) ((((i) << 8) & 0xff00) | (((i) >> 8) & 0x00ff))
/* Read the header, including the name of the file, from file
descriptor IN_DES into FILE_HDR. */
static void read_in_header(struct new_cpio_header *file_hdr, int in_des)
{
long bytes_skipped = 0; /* Bytes of junk found before magic number. */
/* Search for a valid magic number. */
file_hdr->c_tar_linkname = NULL;
tape_buffered_read((char *)file_hdr, in_des, 6L);
while (1) {
if (!strncmp((char *)file_hdr, "070702", 6)
|| !strncmp((char *)file_hdr, "070701", 6))
{
if (bytes_skipped > 0)
warn_junk_bytes(bytes_skipped);
read_in_new_ascii(file_hdr, in_des);
break;
}
bytes_skipped++;
memmove((char *)file_hdr, (char *)file_hdr + 1, 5);
tape_buffered_read((char *)file_hdr + 5, in_des, 1L);
}
}
/* Read the collection from standard input and create files
in the file system. */
static void process_copy_in(void)
{
char done = false; /* True if trailer reached. */
struct new_cpio_header file_hdr; /* Output header information. */
int in_file_des; /* Input file descriptor. */
/* Initialize the copy in. */
file_hdr.c_name = NULL;
/* only from stdin */
in_file_des = 0;
/* While there is more input in the collection, process the input. */
while (!done) {
/* Start processing the next file by reading the header. */
read_in_header(&file_hdr, in_file_des);
/* Is this the header for the TRAILER file? */
if (strcmp("TRAILER!!!", file_hdr.c_name) == 0) {
done = true;
break;
}
/* Copy the input file into the directory structure. */
copyin_file(&file_hdr, in_file_des);
if (dot_flag)
fputc('.', stderr);
}
if (dot_flag)
fputc('\n', stderr);
create_final_defers();
}
/* Initialize the input and output buffers to their proper size and
initialize all variables associated with the input and output
buffers. */
static void initialize_buffers(void)
{
int in_buf_size, out_buf_size;
/* Make sure the input buffer can always hold 2 blocks and that it
is big enough to hold 1 tar record (512 bytes) even if it
is not aligned on a block boundary. The extra buffer space
is needed by process_copyin and peek_in_buf to automatically
figure out what kind of archive it is reading. */
if (io_block_size >= 512)
in_buf_size = 2 * io_block_size;
else
in_buf_size = 1024;
out_buf_size = DISK_IO_BLOCK_SIZE;
input_buffer = (char *)xmalloc(in_buf_size);
in_buff = input_buffer;
input_buffer_size = in_buf_size;
input_size = 0;
input_bytes = 0;
output_buffer = (char *)xmalloc(out_buf_size);
out_buff = output_buffer;
output_size = 0;
output_bytes = 0;
}
int main(int argc, char *argv[])
{
int c;
int extract_flag = false;
progname = argv[0];
do {
c = getopt(argc, argv, "iV");
if (c == EOF)
break;
switch (c) {
case 'V':
dot_flag = true;
break;
case 'i':
extract_flag = true;
break;
case '?':
fprintf(stderr,
"%s: not implemented or invalid option -%c\n",
progname, optopt);
exit(1);
}
} while (1);
if (extract_flag) {
initialize_buffers();
process_copy_in();
} else {
fprintf(stderr, "Usage: %s [-V] -i [< archive]\n", progname);
exit(1);
}
return 0;
}