[unix-history] / 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);
}
Commit	Line	Data
d2fc2cec WJ	1	/*-
	2	* Copyright (c) 1990 The Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* This code is derived from software contributed to Berkeley by
	6	* Hugh Smith at The University of Guelph.
	7	*
	8	* Redistribution and use in source and binary forms, with or without
	9	* modification, are permitted provided that the following conditions
	10	* are met:
	11	* 1. Redistributions of source code must retain the above copyright
	12	* notice, this list of conditions and the following disclaimer.
	13	* 2. Redistributions in binary form must reproduce the above copyright
	14	* notice, this list of conditions and the following disclaimer in the
	15	* documentation and/or other materials provided with the distribution.
	16	* 3. All advertising materials mentioning features or use of this software
	17	* must display the following acknowledgement:
	18	* This product includes software developed by the University of
	19	* California, Berkeley and its contributors.
	20	* 4. Neither the name of the University nor the names of its contributors
	21	* may be used to endorse or promote products derived from this software
	22	* without specific prior written permission.
	23	*
	24	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	25	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	26	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	27	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	28	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	29	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	30	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	31	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	32	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	33	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	34	* SUCH DAMAGE.
	35	*/
	36
	37	#ifndef lint
	38	static char sccsid[] = "@(#)archive.c 5.7 (Berkeley) 3/21/91";
	39	#endif /* not lint */
	40
	41	#include <sys/param.h>
	42	#include <sys/stat.h>
	43	#include <fcntl.h>
	44	#include <unistd.h>
	45	#include <errno.h>
	46	#include <dirent.h>
	47	#include <ar.h>
	48	#include <stdio.h>
	49	#include <stdlib.h>
	50	#include <string.h>
	51	#include "archive.h"
	52	#include "extern.h"
	53
	54	extern CHDR chdr; /* converted header */
	55	extern char archive; / archive name */
	56
	57	typedef struct ar_hdr HDR;
	58	static char hb[sizeof(HDR) + 1]; /* real header */
	59
	60	open_archive(mode)
	61	int mode;
	62	{
	63	int created, fd, nr;
	64	char buf[SARMAG];
65
66	created = 0;
67	if (mode & O_CREAT) {
68	mode \|= O_EXCL;
69	if ((fd = open(archive, mode, DEFFILEMODE)) >= 0) {
70	/* POSIX.2 puts create message on stderr. */
71	if (!(options & AR_C))
72	(void)fprintf(stderr,
73	"ar: creating archive %s.\n", archive);
74	created = 1;
75	goto opened;
76	}
77	if (errno != EEXIST)
78	error(archive);
79	mode &= ~O_EXCL;
80	}
81	if ((fd = open(archive, mode, DEFFILEMODE)) < 0)
82	error(archive);
83
84	/*
85	* Attempt to place a lock on the opened file - if we get an
86	* error then someone is already working on this library (or
87	* it's going across NFS).
88	*/
89	opened: if (flock(fd, LOCK_EX\|LOCK_NB) && errno != EOPNOTSUPP)
90	error(archive);
91
92	/*
93	* If not created, O_RDONLY\|O_RDWR indicates that it has to be
94	* in archive format.
95	*/
96	if (!created &&
97	((mode & O_ACCMODE) == O_RDONLY \|\| (mode & O_ACCMODE) == O_RDWR)) {
98	if ((nr = read(fd, buf, SARMAG) != SARMAG)) {
99	if (nr >= 0)
100	badfmt();
101	error(archive);
102	} else if (bcmp(buf, ARMAG, SARMAG))
103	badfmt();
104	} else if (write(fd, ARMAG, SARMAG) != SARMAG)
105	error(archive);
106	return(fd);
107	}
108
109	void
110	close_archive(fd)
111	int fd;
112	{
113	(void)close(fd); /* Implicit unlock. */
114	}
115
116	/* Convert ar header field to an integer. */
117	#define AR_ATOI(from, to, len, base) { \
118	bcopy(from, buf, len); \
119	buf[len] = '\0'; \
120	to = strtol(buf, (char **)NULL, base); \
121	}
122
123	/*
124	* get_arobj --
125	* read the archive header for this member
126	*/
127	get_arobj(fd)
128	int fd;
129	{
130	struct ar_hdr *hdr;
131	register int len, nr;
132	register char *p, buf[20];
133
134	nr = read(fd, hb, sizeof(HDR));
135	if (nr != sizeof(HDR)) {
136	if (!nr)
137	return(0);
138	if (nr < 0)
139	error(archive);
140	badfmt();
141	}
142
143	hdr = (struct ar_hdr *)hb;
144	if (strncmp(hdr->ar_fmag, ARFMAG, sizeof(ARFMAG) - 1))
145	badfmt();
146
147	/* Convert the header into the internal format. */
148	#define DECIMAL 10
149	#define OCTAL 8
150
151	AR_ATOI(hdr->ar_date, chdr.date, sizeof(hdr->ar_date), DECIMAL);
152	AR_ATOI(hdr->ar_uid, chdr.uid, sizeof(hdr->ar_uid), DECIMAL);
153	AR_ATOI(hdr->ar_gid, chdr.gid, sizeof(hdr->ar_gid), DECIMAL);
154	AR_ATOI(hdr->ar_mode, chdr.mode, sizeof(hdr->ar_mode), OCTAL);
155	AR_ATOI(hdr->ar_size, chdr.size, sizeof(hdr->ar_size), DECIMAL);
156
157	/* Leading spaces should never happen. */
158	if (hdr->ar_name[0] == ' ')
159	badfmt();
160
161	/*
162	* Long name support. Set the "real" size of the file, and the
163	* long name flag/size.
164	*/
165	if (!bcmp(hdr->ar_name, AR_EFMT1, sizeof(AR_EFMT1) - 1)) {
166	chdr.lname = len = atoi(hdr->ar_name + sizeof(AR_EFMT1) - 1);
167	if (len <= 0 \|\| len > MAXNAMLEN)
168	badfmt();
169	nr = read(fd, chdr.name, len);
170	if (nr != len) {
171	if (nr < 0)
172	error(archive);
173	badfmt();
174	}
175	chdr.name[len] = 0;
176	chdr.size -= len;
177	} else {
178	chdr.lname = 0;
179	bcopy(hdr->ar_name, chdr.name, sizeof(hdr->ar_name));
180
181	/* Strip trailing spaces, null terminate. */
182	for (p = chdr.name + sizeof(hdr->ar_name) - 1; *p == ' '; --p);
183	*++p = '\0';
184	}
185	return(1);
186	}
187
188	static int already_written;
189
190	/*
191	* put_arobj --
192	* Write an archive member to a file.
193	*/
194	put_arobj(cfp, sb)
195	CF *cfp;
196	struct stat *sb;
197	{
198	register int lname;
199	register char *name;
200	struct ar_hdr *hdr;
201	off_t size;
202
203	/*
204	* If passed an sb structure, reading a file from disk. Get stat(2)
205	* information, build a name and construct a header. (Files are named
206	* by their last component in the archive.) If not, then just write
207	* the last header read.
208	*/
209	if (sb) {
210	name = rname(cfp->rname);
211	(void)fstat(cfp->rfd, sb);
212
213	/*
214	* If not truncating names and the name is too long or contains
215	* a space, use extended format 1.
216	*/
217	lname = strlen(name);
218	if (options & AR_TR) {
219	if (lname > OLDARMAXNAME) {
220	(void)fflush(stdout);
221	(void)fprintf(stderr,
222	"ar: warning: %s truncated to %.*s\n",
223	name, OLDARMAXNAME, name);
224	(void)fflush(stderr);
225	}
226	(void)sprintf(hb, HDR3, name, sb->st_mtime, sb->st_uid,
227	sb->st_gid, sb->st_mode, sb->st_size, ARFMAG);
228	lname = 0;
229	} else if (lname > sizeof(hdr->ar_name) \|\| index(name, ' '))
230	(void)sprintf(hb, HDR1, AR_EFMT1, lname, sb->st_mtime,
231	sb->st_uid, sb->st_gid, sb->st_mode,
232	sb->st_size + lname, ARFMAG);
233	else {
234	lname = 0;
235	(void)sprintf(hb, HDR2, name, sb->st_mtime, sb->st_uid,
236	sb->st_gid, sb->st_mode, sb->st_size, ARFMAG);
237	}
238	size = sb->st_size;
239	} else {
240	lname = chdr.lname;
241	name = chdr.name;
242	size = chdr.size;
243	}
244
245	if (write(cfp->wfd, hb, sizeof(HDR)) != sizeof(HDR))
246	error(cfp->wname);
247	if (lname) {
248	if (write(cfp->wfd, name, lname) != lname)
249	error(cfp->wname);
250	already_written = lname;
251	}
252	copy_ar(cfp, size);
253	already_written = 0;
254	}
255
256	/*
257	* copy_ar --
258	* Copy size bytes from one file to another - taking care to handle the
259	* extra byte (for odd size files) when reading archives and writing an
260	* extra byte if necessary when adding files to archive. The length of
261	* the object is the long name plus the object itself; the variable
262	* already_written gets set if a long name was written.
263	*
264	* The padding is really unnecessary, and is almost certainly a remnant
265	* of early archive formats where the header included binary data which
266	* a PDP-11 required to start on an even byte boundary. (Or, perhaps,
267	* because 16-bit word addressed copies were faster?) Anyhow, it should
268	* have been ripped out long ago.
269	*/
270	copy_ar(cfp, size)
271	CF *cfp;
272	off_t size;
273	{
274	static char pad = '\n';
275	register off_t sz;
276	register int from, nr, nw, off, to;
277	char buf[8*1024];
278
279	if (!(sz = size))
280	return;
281
282	from = cfp->rfd;
283	to = cfp->wfd;
284	sz = size;
285	while (sz && (nr = read(from, buf, MIN(sz, sizeof(buf)))) > 0) {
286	sz -= nr;
287	for (off = 0; off < nr; nr -= off, off += nw)
288	if ((nw = write(to, buf + off, nr)) < 0)
289	error(cfp->wname);
290	}
291	if (sz) {
292	if (nr == 0)
293	badfmt();
294	error(cfp->rname);
295	}
296
297	if (cfp->flags & RPAD && size & 1 && (nr = read(from, buf, 1)) != 1) {
298	if (nr == 0)
299	badfmt();
300	error(cfp->rname);
301	}
302	if (cfp->flags & WPAD && (size + already_written) & 1 &&
303	write(to, &pad, 1) != 1)
304	error(cfp->wname);
305	}
306
307	/*
308	* skip_arobj -
309	* Skip over an object -- taking care to skip the pad bytes.
310	*/
311	void
312	skip_arobj(fd)
313	int fd;
314	{
315	off_t len;
316
317	len = chdr.size + (chdr.size + chdr.lname & 1);
318	if (lseek(fd, len, SEEK_CUR) == (off_t)-1)
319	error(archive);
320	}