usr/src/usr.bin/ar/archive.c

/*-
 * Copyright (c) 1990 The Regents of the University of California.
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Hugh Smith at The University of Guelph.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by the University of
 *      California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#ifndef lint
static char sccsid[] = "@(#)archive.c   5.7 (Berkeley) 3/21/91";
#endif /* not lint */

#include <sys/param.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <dirent.h>
#include <ar.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "archive.h"
#include "extern.h"

extern CHDR chdr;                       /* converted header */
extern char *archive;                   /* archive name */

typedef struct ar_hdr HDR;
static char hb[sizeof(HDR) + 1];        /* real header */

open_archive(mode)
        int mode;
{
        int created, fd, nr;
        char buf[SARMAG];

        created = 0;
        if (mode & O_CREAT) {
                mode |= O_EXCL;
                if ((fd = open(archive, mode, DEFFILEMODE)) >= 0) {
                        /* POSIX.2 puts create message on stderr. */
                        if (!(options & AR_C))
                                (void)fprintf(stderr,
                                    "ar: creating archive %s.\n", archive);
                        created = 1;
                        goto opened;
                }
                if (errno != EEXIST)
                        error(archive);
                mode &= ~O_EXCL;
        }
        if ((fd = open(archive, mode, DEFFILEMODE)) < 0)
                error(archive);

        /*
         * Attempt to place a lock on the opened file - if we get an
         * error then someone is already working on this library (or
         * it's going across NFS).
         */
opened: if (flock(fd, LOCK_EX|LOCK_NB) && errno != EOPNOTSUPP)
                error(archive);

        /*
         * If not created, O_RDONLY|O_RDWR indicates that it has to be
         * in archive format.
         */
        if (!created &&
            ((mode & O_ACCMODE) == O_RDONLY || (mode & O_ACCMODE) == O_RDWR)) {
                if ((nr = read(fd, buf, SARMAG) != SARMAG)) {
                        if (nr >= 0)
                                badfmt();
                        error(archive);
                } else if (bcmp(buf, ARMAG, SARMAG))
                        badfmt();
        } else if (write(fd, ARMAG, SARMAG) != SARMAG)
                error(archive);
        return(fd);
}

void
close_archive(fd)
        int fd;
{
        (void)close(fd);                        /* Implicit unlock. */
}

/* Convert ar header field to an integer. */
#define AR_ATOI(from, to, len, base) { \
        bcopy(from, buf, len); \
        buf[len] = '\0'; \
        to = strtol(buf, (char **)NULL, base); \
}

/*
 * get_arobj --
 *      read the archive header for this member
 */
get_arobj(fd)
        int fd;
{
        struct ar_hdr *hdr;
        register int len, nr;
        register char *p, buf[20];

        nr = read(fd, hb, sizeof(HDR));
        if (nr != sizeof(HDR)) {
                if (!nr)
                        return(0);
                if (nr < 0)
                        error(archive);
                badfmt();
        }

        hdr = (struct ar_hdr *)hb;
        if (strncmp(hdr->ar_fmag, ARFMAG, sizeof(ARFMAG) - 1))
                badfmt();

        /* Convert the header into the internal format. */
#define DECIMAL 10
#define OCTAL    8

        AR_ATOI(hdr->ar_date, chdr.date, sizeof(hdr->ar_date), DECIMAL);
        AR_ATOI(hdr->ar_uid, chdr.uid, sizeof(hdr->ar_uid), DECIMAL);
        AR_ATOI(hdr->ar_gid, chdr.gid, sizeof(hdr->ar_gid), DECIMAL);
        AR_ATOI(hdr->ar_mode, chdr.mode, sizeof(hdr->ar_mode), OCTAL);
        AR_ATOI(hdr->ar_size, chdr.size, sizeof(hdr->ar_size), DECIMAL);

        /* Leading spaces should never happen. */
        if (hdr->ar_name[0] == ' ')
                badfmt();

        /*
         * Long name support.  Set the "real" size of the file, and the
         * long name flag/size.
         */
        if (!bcmp(hdr->ar_name, AR_EFMT1, sizeof(AR_EFMT1) - 1)) {
                chdr.lname = len = atoi(hdr->ar_name + sizeof(AR_EFMT1) - 1);
                if (len <= 0 || len > MAXNAMLEN)
                        badfmt();
                nr = read(fd, chdr.name, len);
                if (nr != len) {
                        if (nr < 0)
                                error(archive);
                        badfmt();
                }
                chdr.name[len] = 0;
                chdr.size -= len;
        } else {
                chdr.lname = 0;
                bcopy(hdr->ar_name, chdr.name, sizeof(hdr->ar_name));

                /* Strip trailing spaces, null terminate. */
                for (p = chdr.name + sizeof(hdr->ar_name) - 1; *p == ' '; --p);
                *++p = '\0';
        }
        return(1);
}

static int already_written;

/*
 * put_arobj --
 *      Write an archive member to a file.
 */
put_arobj(cfp, sb)
        CF *cfp;
        struct stat *sb;
{
        register int lname;
        register char *name;
        struct ar_hdr *hdr;
        off_t size;

        /*
         * If passed an sb structure, reading a file from disk.  Get stat(2)
         * information, build a name and construct a header.  (Files are named
         * by their last component in the archive.)  If not, then just write
         * the last header read.
         */
        if (sb) {
                name = rname(cfp->rname);
                (void)fstat(cfp->rfd, sb);

                /*
                 * If not truncating names and the name is too long or contains
                 * a space, use extended format 1.
                 */
                lname = strlen(name);
                if (options & AR_TR) {
                        if (lname > OLDARMAXNAME) {
                                (void)fflush(stdout);
                                (void)fprintf(stderr,
                                    "ar: warning: %s truncated to %.*s\n",
                                    name, OLDARMAXNAME, name);
                                (void)fflush(stderr);
                        }
                        (void)sprintf(hb, HDR3, name, sb->st_mtime, sb->st_uid,
                            sb->st_gid, sb->st_mode, sb->st_size, ARFMAG);
                        lname = 0;
                } else if (lname > sizeof(hdr->ar_name) || index(name, ' '))
                        (void)sprintf(hb, HDR1, AR_EFMT1, lname, sb->st_mtime,
                            sb->st_uid, sb->st_gid, sb->st_mode,
                            sb->st_size + lname, ARFMAG);
                else {
                        lname = 0;
                        (void)sprintf(hb, HDR2, name, sb->st_mtime, sb->st_uid,
                            sb->st_gid, sb->st_mode, sb->st_size, ARFMAG);
                }
                size = sb->st_size;
        } else {
                lname = chdr.lname;
                name = chdr.name;
                size = chdr.size;
        }

        if (write(cfp->wfd, hb, sizeof(HDR)) != sizeof(HDR))
                error(cfp->wname);
        if (lname) {
                if (write(cfp->wfd, name, lname) != lname)
                        error(cfp->wname);
                already_written = lname;
        }
        copy_ar(cfp, size);
        already_written = 0;
}

/*
 * copy_ar --
 *      Copy size bytes from one file to another - taking care to handle the
 *      extra byte (for odd size files) when reading archives and writing an
 *      extra byte if necessary when adding files to archive.  The length of
 *      the object is the long name plus the object itself; the variable
 *      already_written gets set if a long name was written.
 *
 *      The padding is really unnecessary, and is almost certainly a remnant
 *      of early archive formats where the header included binary data which
 *      a PDP-11 required to start on an even byte boundary.  (Or, perhaps,
 *      because 16-bit word addressed copies were faster?)  Anyhow, it should
 *      have been ripped out long ago.
 */
copy_ar(cfp, size)
        CF *cfp;
        off_t size;
{
        static char pad = '\n';
        register off_t sz;
        register int from, nr, nw, off, to;
        char buf[8*1024];

        if (!(sz = size))
                return;

        from = cfp->rfd;
        to = cfp->wfd;
        sz = size;
        while (sz && (nr = read(from, buf, MIN(sz, sizeof(buf)))) > 0) {
                sz -= nr;
                for (off = 0; off < nr; nr -= off, off += nw)
                        if ((nw = write(to, buf + off, nr)) < 0)
                                error(cfp->wname);
        }
        if (sz) {
                if (nr == 0)
                        badfmt();
                error(cfp->rname);
        }

        if (cfp->flags & RPAD && size & 1 && (nr = read(from, buf, 1)) != 1) {
                if (nr == 0)
                        badfmt();
                error(cfp->rname);
        }
        if (cfp->flags & WPAD && (size + already_written) & 1 &&
            write(to, &pad, 1) != 1)
                error(cfp->wname);
}

/*
 * skip_arobj -
 *      Skip over an object -- taking care to skip the pad bytes.
 */
void
skip_arobj(fd)
        int fd;
{
        off_t len;

        len = chdr.size + (chdr.size + chdr.lname & 1);
        if (lseek(fd, len, SEEK_CUR) == (off_t)-1)
                error(archive);
}