1/*
2 * ----------------------------------------------------------------------------
3 * "THE BEER-WARE LICENSE" (Revision 42):
4 * <sobomax@FreeBSD.ORG> wrote this file. As long as you retain this notice you
5 * can do whatever you want with this stuff. If we meet some day, and you think
6 * this stuff is worth it, you can buy me a beer in return.       Maxim Sobolev
7 * ----------------------------------------------------------------------------
8 *
9 * $FreeBSD$
10 *
11 */
12
13#include <sys/types.h>
14#include <sys/disk.h>
15#include <sys/endian.h>
16#include <sys/param.h>
17#include <sys/stat.h>
18#include <sys/uio.h>
19#include <netinet/in.h>
20#include <zlib.h>
21#include <err.h>
22#include <fcntl.h>
23#include <signal.h>
24#include <stdio.h>
25#include <stdlib.h>
26#include <string.h>
27#include <unistd.h>
28
29#define CLSTSIZE	16384
30#define DEFAULT_SUFX	".uzip"
31
32#define CLOOP_MAGIC_LEN 128
33static char CLOOP_MAGIC_START[] = "#!/bin/sh\n#V2.0 Format\n"
34    "(kldstat -qm g_uzip||kldload geom_uzip)>&-&&"
35    "mount_cd9660 /dev/`mdconfig -af $0`.uzip $1\nexit $?\n";
36
37static char *readblock(int, char *, u_int32_t);
38static void usage(void);
39static void *safe_malloc(size_t);
40static void cleanup(void);
41
42static char *cleanfile = NULL;
43
44int main(int argc, char **argv)
45{
46	char *iname, *oname, *obuf, *ibuf;
47	uint64_t *toc;
48	int fdr, fdw, i, opt, verbose, tmp;
49	struct iovec iov[2];
50	struct stat sb;
51	uLongf destlen;
52	uint64_t offset;
53	struct cloop_header {
54		char magic[CLOOP_MAGIC_LEN];    /* cloop magic */
55		uint32_t blksz;                 /* block size */
56		uint32_t nblocks;               /* number of blocks */
57	} hdr;
58
59	memset(&hdr, 0, sizeof(hdr));
60	hdr.blksz = CLSTSIZE;
61	strcpy(hdr.magic, CLOOP_MAGIC_START);
62	oname = NULL;
63	verbose = 0;
64
65	while((opt = getopt(argc, argv, "o:s:v")) != -1) {
66		switch(opt) {
67		case 'o':
68			oname = optarg;
69			break;
70
71		case 's':
72			tmp = atoi(optarg);
73			if (tmp <= 0) {
74				errx(1, "invalid cluster size specified: %s",
75				    optarg);
76				/* Not reached */
77			}
78			if (tmp % DEV_BSIZE != 0) {
79				errx(1, "cluster size should be multiple of %d",
80				    DEV_BSIZE);
81				/* Not reached */
82			}
83			if (compressBound(tmp) > MAXPHYS) {
84				errx(1, "cluster size is too large");
85				    /* Not reached */
86			}
87			hdr.blksz = tmp;
88			break;
89
90		case 'v':
91			verbose = 1;
92			break;
93
94		default:
95			usage();
96			/* Not reached */
97		}
98	}
99	argc -= optind;
100	argv += optind;
101
102	if (argc != 1) {
103		usage();
104		/* Not reached */
105	}
106
107	iname = argv[0];
108	if (oname == NULL) {
109		asprintf(&oname, "%s%s", iname, DEFAULT_SUFX);
110		if (oname == NULL) {
111			err(1, "can't allocate memory");
112			/* Not reached */
113		}
114	}
115
116	obuf = safe_malloc(compressBound(hdr.blksz));
117	ibuf = safe_malloc(hdr.blksz);
118
119	signal(SIGHUP, exit);
120	signal(SIGINT, exit);
121	signal(SIGTERM, exit);
122	signal(SIGXCPU, exit);
123	signal(SIGXFSZ, exit);
124	atexit(cleanup);
125
126	fdr = open(iname, O_RDONLY);
127	if (fdr < 0) {
128		err(1, "open(%s)", iname);
129		/* Not reached */
130	}
131	if (fstat(fdr, &sb) != 0) {
132		err(1, "fstat(%s)", iname);
133		/* Not reached */
134	}
135	if (S_ISCHR(sb.st_mode)) {
136		off_t ms;
137
138		if (ioctl(fdr, DIOCGMEDIASIZE, &ms) < 0) {
139			err(1, "ioctl(DIOCGMEDIASIZE)");
140			/* Not reached */
141		}
142		sb.st_size = ms;
143	} else if (!S_ISREG(sb.st_mode)) {
144		fprintf(stderr, "%s: not a character device or regular file\n",
145			iname);
146		exit(1);
147	}
148	hdr.nblocks = sb.st_size / hdr.blksz;
149	if ((sb.st_size % hdr.blksz) != 0) {
150		if (verbose != 0)
151			fprintf(stderr, "file size is not multiple "
152			"of %d, padding data\n", hdr.blksz);
153		hdr.nblocks++;
154	}
155	toc = safe_malloc((hdr.nblocks + 1) * sizeof(*toc));
156
157	fdw = open(oname, O_WRONLY | O_TRUNC | O_CREAT,
158		   S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
159	if (fdw < 0) {
160		err(1, "open(%s)", oname);
161		/* Not reached */
162	}
163	cleanfile = oname;
164
165	/* Prepare header that we will write later when we have index ready. */
166	iov[0].iov_base = (char *)&hdr;
167	iov[0].iov_len = sizeof(hdr);
168	iov[1].iov_base = (char *)toc;
169	iov[1].iov_len = (hdr.nblocks + 1) * sizeof(*toc);
170	offset = iov[0].iov_len + iov[1].iov_len;
171
172	/* Reserve space for header */
173	lseek(fdw, offset, SEEK_SET);
174
175	if (verbose != 0)
176		fprintf(stderr, "data size %ju bytes, number of clusters "
177		    "%u, index length %zu bytes\n", sb.st_size,
178		    hdr.nblocks, iov[1].iov_len);
179
180	for(i = 0; i == 0 || ibuf != NULL; i++) {
181		ibuf = readblock(fdr, ibuf, hdr.blksz);
182		if (ibuf != NULL) {
183			destlen = compressBound(hdr.blksz);
184			if (compress2(obuf, &destlen, ibuf, hdr.blksz,
185			    Z_BEST_COMPRESSION) != Z_OK) {
186				errx(1, "can't compress data: compress2() "
187				    "failed");
188				/* Not reached */
189			}
190			if (verbose != 0)
191				fprintf(stderr, "cluster #%d, in %u bytes, "
192				    "out %lu bytes\n", i, hdr.blksz, destlen);
193		} else {
194			destlen = DEV_BSIZE - (offset % DEV_BSIZE);
195			memset(obuf, 0, destlen);
196			if (verbose != 0)
197				fprintf(stderr, "padding data with %lu bytes so "
198				    "that file size is multiple of %d\n", destlen,
199				    DEV_BSIZE);
200		}
201		if (write(fdw, obuf, destlen) < 0) {
202			err(1, "write(%s)", oname);
203			/* Not reached */
204		}
205		toc[i] = htobe64(offset);
206		offset += destlen;
207	}
208	close(fdr);
209
210	if (verbose != 0)
211		fprintf(stderr, "compressed data to %ju bytes, saved %lld "
212		    "bytes, %.2f%% decrease.\n", offset, (long long)(sb.st_size - offset),
213		    100.0 * (long long)(sb.st_size - offset) / (float)sb.st_size);
214
215	/* Convert to big endian */
216	hdr.blksz = htonl(hdr.blksz);
217	hdr.nblocks = htonl(hdr.nblocks);
218	/* Write headers into pre-allocated space */
219	lseek(fdw, 0, SEEK_SET);
220	if (writev(fdw, iov, 2) < 0) {
221		err(1, "writev(%s)", oname);
222		/* Not reached */
223	}
224	cleanfile = NULL;
225	close(fdw);
226
227	exit(0);
228}
229
230static char *
231readblock(int fd, char *ibuf, u_int32_t clstsize)
232{
233	int numread;
234
235	bzero(ibuf, clstsize);
236	numread = read(fd, ibuf, clstsize);
237	if (numread < 0) {
238		err(1, "read() failed");
239		/* Not reached */
240	}
241	if (numread == 0) {
242		return NULL;
243	}
244	return ibuf;
245}
246
247static void
248usage(void)
249{
250
251	fprintf(stderr, "usage: mkuzip [-v] [-o outfile] [-s cluster_size] infile\n");
252	exit(1);
253}
254
255static void *
256safe_malloc(size_t size)
257{
258	void *retval;
259
260	retval = malloc(size);
261	if (retval == NULL) {
262		err(1, "can't allocate memory");
263		/* Not reached */
264	}
265	return retval;
266}
267
268static void
269cleanup(void)
270{
271
272	if (cleanfile != NULL)
273		unlink(cleanfile);
274}
275