dist/contrib/untar.c

/*
 * This file is in the public domain.  Use it as you see fit.
 */

/*
 * "untar" is an extremely simple tar extractor:
 *  * A single C source file, so it should be easy to compile
 *    and run on any system with a C compiler.
 *  * Extremely portable standard C.  The only non-ANSI function
 *    used is mkdir().
 *  * Reads basic ustar tar archives.
 *  * Does not require libarchive or any other special library.
 *
 * To compile: cc -o untar untar.c
 *
 * Usage:  untar <archive>
 *
 * In particular, this program should be sufficient to extract the
 * distribution for libarchive, allowing people to bootstrap
 * libarchive on systems that do not already have a tar program.
 *
 * To unpack libarchive-x.y.z.tar.gz:
 *    * gunzip libarchive-x.y.z.tar.gz
 *    * untar libarchive-x.y.z.tar
 *
 * Written by Tim Kientzle, March 2009.
 *
 * Released into the public domain.
 */

/* These are all highly standard and portable headers. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* This is for mkdir(); this may need to be changed for some platforms. */
#include <sys/stat.h>  /* For mkdir() */

/* Parse an octal number, ignoring leading and trailing nonsense. */
static int
parseoct(const char *p, size_t n)
{
        int i = 0;

        while ((*p < '0' || *p > '7') && n > 0) {
                ++p;
                --n;
        }
        while (*p >= '0' && *p <= '7' && n > 0) {
                i *= 8;
                i += *p - '0';
                ++p;
                --n;
        }
        return (i);
}

/* Returns true if this is 512 zero bytes. */
static int
is_end_of_archive(const char *p)
{
        int n;
        for (n = 511; n >= 0; --n)
                if (p[n] != '\0')
                        return (0);
        return (1);
}

/* Create a directory, including parent directories as necessary. */
static void
create_dir(char *pathname, int mode)
{
        char *p;
        int r;

        /* Strip trailing '/' */
        if (pathname[strlen(pathname) - 1] == '/')
                pathname[strlen(pathname) - 1] = '\0';

        /* Try creating the directory. */
        r = mkdir(pathname, mode);

        if (r != 0) {
                /* On failure, try creating parent directory. */
                p = strrchr(pathname, '/');
                if (p != NULL) {
                        *p = '\0';
                        create_dir(pathname, 0755);
                        *p = '/';
                        r = mkdir(pathname, mode);
                }
        }
        if (r != 0)
                fprintf(stderr, "Could not create directory %s\n", pathname);
}

/* Create a file, including parent directory as necessary. */
static FILE *
create_file(char *pathname, int mode)
{
        FILE *f;
        f = fopen(pathname, "wb+");
        if (f == NULL) {
                /* Try creating parent dir and then creating file. */
                char *p = strrchr(pathname, '/');
                if (p != NULL) {
                        *p = '\0';
                        create_dir(pathname, 0755);
                        *p = '/';
                        f = fopen(pathname, "wb+");
                }
        }
        return (f);
}

/* Verify the tar checksum. */
static int
verify_checksum(const char *p)
{
        int n, u = 0;
        for (n = 0; n < 512; ++n) {
                if (n < 148 || n > 155)
                        /* Standard tar checksum adds unsigned bytes. */
                        u += ((unsigned char *)p)[n];
                else
                        u += 0x20;

        }
        return (u == parseoct(p + 148, 8));
}

/* Extract a tar archive. */
static void
untar(FILE *a, const char *path)
{
        char buff[512];
        FILE *f = NULL;
        size_t bytes_read;
        int filesize;

        printf("Extracting from %s\n", path);
        for (;;) {
                bytes_read = fread(buff, 1, 512, a);
                if (bytes_read < 512) {
                        fprintf(stderr,
                            "Short read on %s: expected 512, got %d\n",
                            path, (int)bytes_read);
                        return;
                }
                if (is_end_of_archive(buff)) {
                        printf("End of %s\n", path);
                        return;
                }
                if (!verify_checksum(buff)) {
                        fprintf(stderr, "Checksum failure\n");
                        return;
                }
                filesize = parseoct(buff + 124, 12);
                switch (buff[156]) {
                case '1':
                        printf(" Ignoring hardlink %s\n", buff);
                        break;
                case '2':
                        printf(" Ignoring symlink %s\n", buff);
                        break;
                case '3':
                        printf(" Ignoring character device %s\n", buff);
                                break;
                case '4':
                        printf(" Ignoring block device %s\n", buff);
                        break;
                case '5':
                        printf(" Extracting dir %s\n", buff);
                        create_dir(buff, parseoct(buff + 100, 8));
                        filesize = 0;
                        break;
                case '6':
                        printf(" Ignoring FIFO %s\n", buff);
                        break;
                default:
                        printf(" Extracting file %s\n", buff);
                        f = create_file(buff, parseoct(buff + 100, 8));
                        break;
                }
                while (filesize > 0) {
                        bytes_read = fread(buff, 1, 512, a);
                        if (bytes_read < 512) {
                                fprintf(stderr,
                                    "Short read on %s: Expected 512, got %d\n",
                                    path, (int)bytes_read);
                                return;
                        }
                        if (filesize < 512)
                                bytes_read = filesize;
                        if (f != NULL) {
                                if (fwrite(buff, 1, bytes_read, f)
                                    != bytes_read)
                                {
                                        fprintf(stderr, "Failed write\n");
                                        fclose(f);
                                        f = NULL;
                                }
                        }
                        filesize -= bytes_read;
                }
                if (f != NULL) {
                        fclose(f);
                        f = NULL;
                }
        }
}

int
main(int argc, char **argv)
{
        FILE *a;

        ++argv; /* Skip program name */
        for ( ;*argv != NULL; ++argv) {
                a = fopen(*argv, "rb");
                if (a == NULL)
                        fprintf(stderr, "Unable to open %s\n", *argv);
                else {
                        untar(a, *argv);
                        fclose(a);
                }
        }
        return (0);
}
Revision:	9165
Committed:	Fri Oct 14 02:40:30 2016 UTC (7 years, 6 months ago) by laffer1
Content type:	text/plain
File size:	4869 byte(s)
Log Message:	libarchive 3.2.1
#	Content
1	/*
2	* This file is in the public domain. Use it as you see fit.
3	*/
4
5	/*
6	* "untar" is an extremely simple tar extractor:
7	* * A single C source file, so it should be easy to compile
8	* and run on any system with a C compiler.
9	* * Extremely portable standard C. The only non-ANSI function
10	* used is mkdir().
11	* * Reads basic ustar tar archives.
12	* * Does not require libarchive or any other special library.
13	*
14	* To compile: cc -o untar untar.c
15	*
16	* Usage: untar <archive>
17	*
18	* In particular, this program should be sufficient to extract the
19	* distribution for libarchive, allowing people to bootstrap
20	* libarchive on systems that do not already have a tar program.
21	*
22	* To unpack libarchive-x.y.z.tar.gz:
23	* * gunzip libarchive-x.y.z.tar.gz
24	* * untar libarchive-x.y.z.tar
25	*
26	* Written by Tim Kientzle, March 2009.
27	*
28	* Released into the public domain.
29	*/
30
31	/* These are all highly standard and portable headers. */
32	#include <stdio.h>
33	#include <stdlib.h>
34	#include <string.h>
35
36	/* This is for mkdir(); this may need to be changed for some platforms. */
37	#include <sys/stat.h> /* For mkdir() */
38
39	/* Parse an octal number, ignoring leading and trailing nonsense. */
40	static int
41	parseoct(const char *p, size_t n)
42	{
43	int i = 0;
44
45	while ((p < '0' \|\| p > '7') && n > 0) {
46	++p;
47	--n;
48	}
49	while (p >= '0' && p <= '7' && n > 0) {
50	i *= 8;
51	i += *p - '0';
52	++p;
53	--n;
54	}
55	return (i);
56	}
57
58	/* Returns true if this is 512 zero bytes. */
59	static int
60	is_end_of_archive(const char *p)
61	{
62	int n;
63	for (n = 511; n >= 0; --n)
64	if (p[n] != '\0')
65	return (0);
66	return (1);
67	}
68
69	/* Create a directory, including parent directories as necessary. */
70	static void
71	create_dir(char *pathname, int mode)
72	{
73	char *p;
74	int r;
75
76	/* Strip trailing '/' */
77	if (pathname[strlen(pathname) - 1] == '/')
78	pathname[strlen(pathname) - 1] = '\0';
79
80	/* Try creating the directory. */
81	r = mkdir(pathname, mode);
82
83	if (r != 0) {
84	/* On failure, try creating parent directory. */
85	p = strrchr(pathname, '/');
86	if (p != NULL) {
87	*p = '\0';
88	create_dir(pathname, 0755);
89	*p = '/';
90	r = mkdir(pathname, mode);
91	}
92	}
93	if (r != 0)
94	fprintf(stderr, "Could not create directory %s\n", pathname);
95	}
96
97	/* Create a file, including parent directory as necessary. */
98	static FILE *
99	create_file(char *pathname, int mode)
100	{
101	FILE *f;
102	f = fopen(pathname, "wb+");
103	if (f == NULL) {
104	/* Try creating parent dir and then creating file. */
105	char *p = strrchr(pathname, '/');
106	if (p != NULL) {
107	*p = '\0';
108	create_dir(pathname, 0755);
109	*p = '/';
110	f = fopen(pathname, "wb+");
111	}
112	}
113	return (f);
114	}
115
116	/* Verify the tar checksum. */
117	static int
118	verify_checksum(const char *p)
119	{
120	int n, u = 0;
121	for (n = 0; n < 512; ++n) {
122	if (n < 148 \|\| n > 155)
123	/* Standard tar checksum adds unsigned bytes. */
124	u += ((unsigned char *)p)[n];
125	else
126	u += 0x20;
127
128	}
129	return (u == parseoct(p + 148, 8));
130	}
131
132	/* Extract a tar archive. */
133	static void
134	untar(FILE a, const char path)
135	{
136	char buff[512];
137	FILE *f = NULL;
138	size_t bytes_read;
139	int filesize;
140
141	printf("Extracting from %s\n", path);
142	for (;;) {
143	bytes_read = fread(buff, 1, 512, a);
144	if (bytes_read < 512) {
145	fprintf(stderr,
146	"Short read on %s: expected 512, got %d\n",
147	path, (int)bytes_read);
148	return;
149	}
150	if (is_end_of_archive(buff)) {
151	printf("End of %s\n", path);
152	return;
153	}
154	if (!verify_checksum(buff)) {
155	fprintf(stderr, "Checksum failure\n");
156	return;
157	}
158	filesize = parseoct(buff + 124, 12);
159	switch (buff[156]) {
160	case '1':
161	printf(" Ignoring hardlink %s\n", buff);
162	break;
163	case '2':
164	printf(" Ignoring symlink %s\n", buff);
165	break;
166	case '3':
167	printf(" Ignoring character device %s\n", buff);
168	break;
169	case '4':
170	printf(" Ignoring block device %s\n", buff);
171	break;
172	case '5':
173	printf(" Extracting dir %s\n", buff);
174	create_dir(buff, parseoct(buff + 100, 8));
175	filesize = 0;
176	break;
177	case '6':
178	printf(" Ignoring FIFO %s\n", buff);
179	break;
180	default:
181	printf(" Extracting file %s\n", buff);
182	f = create_file(buff, parseoct(buff + 100, 8));
183	break;
184	}
185	while (filesize > 0) {
186	bytes_read = fread(buff, 1, 512, a);
187	if (bytes_read < 512) {
188	fprintf(stderr,
189	"Short read on %s: Expected 512, got %d\n",
190	path, (int)bytes_read);
191	return;
192	}
193	if (filesize < 512)
194	bytes_read = filesize;
195	if (f != NULL) {
196	if (fwrite(buff, 1, bytes_read, f)
197	!= bytes_read)
198	{
199	fprintf(stderr, "Failed write\n");
200	fclose(f);
201	f = NULL;
202	}
203	}
204	filesize -= bytes_read;
205	}
206	if (f != NULL) {
207	fclose(f);
208	f = NULL;
209	}
210	}
211	}
212
213	int
214	main(int argc, char **argv)
215	{
216	FILE *a;
217
218	++argv; /* Skip program name */
219	for ( ;*argv != NULL; ++argv) {
220	a = fopen(*argv, "rb");
221	if (a == NULL)
222	fprintf(stderr, "Unable to open %s\n", *argv);
223	else {
224	untar(a, *argv);
225	fclose(a);
226	}
227	}
228	return (0);
229	}