usr.bin/vndcompress/vndcompress.c

   1 /* $Id: vndcompress.c,v 1.6 2009/04/14 07:36:16 lukem Exp $ */
   2
   3 /*
   4  * Copyright (c) 2005 by Florian Stoehr <netbsd@wolfnode.de>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *        This product includes software developed by Florian Stoehr
  18  * 4. The name of Florian Stoehr may not be used to endorse or promote
  19  *    products derived from this software without specific prior written
  20  *    permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY FLORIAN STOEHR ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  24  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  25  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  26  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  27  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  28  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  29  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  30  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  31  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  32  * POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 /*
  36  * cloop2 - Compressed filesystem images
  37  * vndcompress program - Compress/decompress filesystem images to
  38  * the cloop2 format
  39  */
  40 #include <err.h>
  41 #include <fcntl.h>
  42 #include <inttypes.h>
  43 #include <stdarg.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <unistd.h>
  48 #include <zlib.h>
  49
  50 #include "vndcompress.h"
  51
  52 enum opermodes {
  53         OM_COMPRESS,    /* Compress a fs       */
  54         OM_UNCOMPRESS,  /* Uncompress an image */
  55 };
  56
  57 /*
  58  * This is the original header of the Linux files. It is useless
  59  * on NetBSD and integrated for compatibility issues only.
  60  */
  61 static const char *cloop_sh = "#!/bin/sh\n" "#V2.0 Format\n" "insmod cloop.o file=$0 && mount -r -t iso9660 /dev/cloop $1\n" "exit $?\n";
  62
  63 int opmode;
  64
  65 /*
  66  * Print usage information, then exit program
  67  */
  68 void
  69 usage(void)
  70 {
  71         if (opmode == OM_COMPRESS) {
  72                 printf("usage: vndcompress [-cd] disk/fs-image compressed-image [blocksize]\n");
  73         } else {
  74                 printf("usage: vnduncompress [-cd] compressed-image disk/fs-image\n");
  75         }
  76
  77         exit(EXIT_FAILURE);
  78 }
  79
  80 /*
  81  * Compress a given file system
  82  */
  83 void
  84 vndcompress(const char *fs, const char *comp, uint32_t blocksize)
  85 {
  86         int fd_in, fd_out;
  87         int total_blocks, offtable_size;
  88         int i;
  89         int read_blocksize;
  90         off_t fsize, diffatom, cursize;
  91         struct cloop_header clh;
  92         uint64_t *offtable;
  93         uint64_t curoff;
  94         unsigned long complen;
  95         unsigned char *cb, *ucb;
  96
  97         fd_in = open(fs, O_RDONLY);
  98
  99         if (fd_in < 0)
 100                 err(EXIT_FAILURE, "Cannot open input file \"%s\"", fs);
 101                 /* NOTREACHED */
 102
 103         fd_out = open(comp, O_CREAT | O_TRUNC | O_WRONLY,
 104                 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 105
 106         if (fd_out < 0)
 107                 err(EXIT_FAILURE, "Cannot create output file \"%s\"", comp);
 108                 /* NOTREACHED */
 109
 110         if ((blocksize % ATOMBLOCK) || (blocksize < ATOMBLOCK))
 111                 errx(EXIT_FAILURE, "Invalid block size: %d (Block size must be "\
 112                         "a multiple of %d Bytes)", blocksize, ATOMBLOCK);
 113                 /* NOTREACHED */
 114
 115         /*
 116          * Init the compression
 117          */
 118
 119         /* Determine number of total input blocks, round up to complete blocks */
 120         fsize = lseek(fd_in, 0, SEEK_END);
 121         lseek(fd_in, 0, SEEK_SET);
 122         total_blocks = fsize / blocksize;
 123
 124         printf("Using blocksize: %d ", blocksize);
 125
 126         if (fsize % blocksize) {
 127                 printf("(%d complete and 1 zero-padded blocks)\n", total_blocks);
 128                 total_blocks++;
 129         } else {
 130                 printf("(%d complete blocks)\n", total_blocks);
 131         }
 132
 133         /* Struct fillup */
 134         memset(&clh, 0, sizeof(struct cloop_header));
 135         memcpy(clh.sh, cloop_sh, strlen(cloop_sh));
 136
 137         /* Remember the header is also in network format! */
 138         clh.block_size = SWAPPER32(blocksize);
 139         clh.num_blocks = SWAPPER32(total_blocks);
 140
 141         /* Prepare the offset table (unsigned 64-bit big endian offsets) */
 142         offtable_size = (total_blocks + 1) * sizeof(uint64_t);
 143         offtable = (uint64_t *)malloc(offtable_size);
 144
 145         /*
 146          * Setup block buffers.
 147          * Since compression may actually stretch a block in bad cases,
 148          * make the "compressed" space large enough here.
 149          */
 150         ucb = (unsigned char *)malloc(blocksize);
 151         cb = (unsigned char *)malloc(blocksize * 2);
 152
 153         /*
 154          * Compression
 155          *
 156          * We'll leave file caching to the operating system and write
 157          * first the (fixed-size) header with dummy-data, then the compressed
 158          * blocks block-by-block to disk. After that, we overwrite the offset
 159          * table in the image file with the real offset table.
 160          */
 161         if ((size_t)write(fd_out, &clh, sizeof(struct cloop_header))
 162                 != sizeof(struct cloop_header))
 163                 err(EXIT_FAILURE, "Cannot write to output file \"%s\"", comp);
 164                 /* NOTREACHED */
 165
 166         if (write(fd_out, offtable, offtable_size) < offtable_size)
 167                 err(EXIT_FAILURE, "Cannot write to output file \"%s\"", comp);
 168                 /* NOTREACHED */
 169
 170         /*
 171          * Offsets are relative to the beginning of the file, not
 172          * relative to offset table start
 173          */
 174         curoff = sizeof(struct cloop_header) + offtable_size;
 175
 176         /* Compression loop */
 177         for (i = 0; i < total_blocks; i++) {
 178
 179                 /* By default, assume to read blocksize bytes */
 180                 read_blocksize = blocksize;
 181
 182                 /*
 183                  * However, the last block may be smaller than block size.
 184                  * If this is the case, pad uncompressed buffer with zeros
 185                  * (by zero-filling before the read() call)
 186                  */
 187                 if (i == total_blocks - 1) {
 188                         if (fsize % blocksize) {
 189                                 read_blocksize = fsize % blocksize;
 190                                 memset(ucb, 0x00, blocksize);
 191                         }
 192                 }
 193
 194                 if (read(fd_in, ucb, read_blocksize) < read_blocksize)
 195                         err(EXIT_FAILURE, "Cannot read input file \"%s\"", fs);
 196                         /* NOTREACHED */
 197
 198                 complen = blocksize * 2;
 199
 200                 if (compress2(cb, &complen, ucb, blocksize, Z_BEST_COMPRESSION) != Z_OK)
 201                         errx(EXIT_FAILURE, "Compression failed in block %d", i);
 202                         /* NOTREACHED */
 203
 204                 if ((unsigned long)write(fd_out, cb, complen) != complen)
 205                         err(EXIT_FAILURE, "Cannot write to output file \"%s\"", comp);
 206                         /* NOTREACHED */
 207
 208                 *(offtable + i) = SWAPPER(curoff);
 209                 curoff += complen;
 210         }
 211
 212         /* Always write +1 block to determine (compressed) block size */
 213         *(offtable + total_blocks) = SWAPPER(curoff);
 214
 215         /* Fixup compression table */
 216         lseek(fd_out, sizeof(struct cloop_header), SEEK_SET);
 217
 218         if (write(fd_out, offtable, offtable_size) < offtable_size)
 219                 err(EXIT_FAILURE, "Cannot write to output file \"%s\"", comp);
 220                 /* NOTREACHED */
 221
 222         /* Finally, align the image size to be a multiple of ATOMBLOCK bytes */
 223         cursize = lseek(fd_out, 0, SEEK_END);
 224
 225         if (cursize % ATOMBLOCK) {
 226                 /*
 227                  * Reusing the cb buffer here. It *IS* large enough since
 228                  * blocksize may not be smaller than ATOMBLOCK
 229                  */
 230                 diffatom = (((cursize / ATOMBLOCK) + 1) * ATOMBLOCK) - cursize;
 231                 memset(cb, 0, blocksize * 2);
 232                 write(fd_out, cb, diffatom);
 233         }
 234
 235         free(cb);
 236         free(ucb);
 237         free(offtable);
 238
 239         close(fd_in);
 240         close(fd_out);
 241 }
 242
 243 /*
 244  * Read in header and offset table from compressed image
 245  */
 246 uint64_t *
 247 readheader(int fd, struct cloop_header *clh, off_t *dstart)
 248 {
 249         uint32_t offtable_size;
 250         uint64_t *offt;
 251
 252         if ((size_t)read(fd, clh, sizeof(struct cloop_header))
 253                 != sizeof(struct cloop_header))
 254                 return NULL;
 255
 256         /* Convert endianness */
 257         clh->block_size = SWAPPER32(clh->block_size);
 258         clh->num_blocks = SWAPPER32(clh->num_blocks);
 259
 260         offtable_size = (clh->num_blocks + 1) * sizeof(uint64_t);
 261         offt = (uint64_t *)malloc(offtable_size);
 262
 263         if ((uint32_t)read(fd, offt, offtable_size) != offtable_size) {
 264                 free(offt);
 265                 return NULL;
 266         }
 267
 268         *dstart = offtable_size + sizeof(struct cloop_header);
 269
 270         return offt;
 271 }
 272
 273 /*
 274  * Decompress a given file system image
 275  */
 276 void
 277 vnduncompress(const char *comp, const char *fs)
 278 {
 279         int fd_in, fd_out;
 280         uint32_t i;
 281         struct cloop_header clh;
 282         uint64_t *offtable;
 283         off_t imgofs, datastart;
 284         unsigned long complen, uncomplen;
 285         unsigned char *cb, *ucb;
 286
 287         /*
 288          * Setup decompression, read in header tables
 289          */
 290         fd_in = open(comp, O_RDONLY);
 291
 292         if (fd_in < 0)
 293                 err(EXIT_FAILURE, "Cannot open input file \"%s\"", comp);
 294                 /* NOTREACHED */
 295
 296         fd_out = open(fs, O_CREAT | O_TRUNC | O_WRONLY,
 297                 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 298
 299         if (fd_out < 0)
 300                 err(EXIT_FAILURE, "Cannot create output file \"%s\"", fs);
 301                 /* NOTREACHED */
 302
 303         offtable = readheader(fd_in, &clh, &datastart);
 304
 305         if (offtable == NULL)
 306                 errx(EXIT_FAILURE, "Input file \"%s\": Size mismatch, too small to be a valid image", comp);
 307                 /* NOTREACHED */
 308
 309         /* As for the compression, alloc the compressed block bigger */
 310         ucb = (unsigned char *)malloc(clh.block_size);
 311         cb = (unsigned char *)malloc(clh.block_size * 2);
 312
 313         /*
 314          * Perform the actual decompression
 315          */
 316         for (i = 0; i < clh.num_blocks; i++) {
 317                 int rc;
 318
 319                 imgofs = SWAPPER(*(offtable + i));
 320                 lseek(fd_in, imgofs, SEEK_SET);
 321
 322                 complen = SWAPPER(*(offtable + i + 1))
 323                            - SWAPPER(*(offtable + i));
 324
 325                 if ((unsigned long)read(fd_in, cb, complen) != complen)
 326                         err(EXIT_FAILURE, "Cannot read compressed block %"PRIu32" from \"%s\"", i, comp);
 327                         /* NOTREACHED */
 328
 329                 uncomplen = clh.block_size;
 330                 rc = uncompress(ucb, &uncomplen, cb, complen);
 331                 if (rc != Z_OK)
 332                         errx(EXIT_FAILURE, "Cannot decompress block %"PRIu32" from \"%s\" (rc=%d)",
 333                             i, comp, rc);
 334                         /* NOTREACHED */
 335
 336                 write(fd_out, ucb, clh.block_size);
 337         }
 338
 339         free(cb);
 340         free(ucb);
 341         free(offtable);
 342
 343         close(fd_in);
 344         close(fd_out);
 345 }
 346
 347 /*
 348  * vndcompress: Handle cloop2-compatible compressed file systems; This is the
 349  *              user-level configuration program, to be used in conjunction
 350  *              with the vnd(4) driver.
 351  */
 352 int
 353 main(int argc, char **argv)
 354 {
 355         char *ep, *p;
 356         int ch;
 357
 358         setprogname(argv[0]);
 359
 360         if ((p = strrchr(argv[0], '/')) == NULL)
 361                 p = argv[0];
 362         else
 363                 ++p;
 364         if (strcmp(p, "vnduncompress") == 0)
 365                 opmode = OM_UNCOMPRESS;
 366         else if (strcmp(p, "vndcompress") == 0)
 367                 opmode = OM_COMPRESS;
 368         else
 369                 warnx("unknown program name '%s'", p);
 370
 371         /* Process command-line options */
 372         while ((ch = getopt(argc, argv, "cd")) != -1) {
 373                 switch (ch) {
 374                 case 'c':
 375                         opmode = OM_COMPRESS;
 376                         break;
 377
 378                 case 'd':
 379                         opmode = OM_UNCOMPRESS;
 380                         break;
 381
 382                 default:
 383                         usage();
 384                         /* NOTREACHED */
 385                 }
 386         }
 387
 388         argc -= optind;
 389         argv += optind;
 390
 391         if (argc < 2) {
 392                 usage();
 393                 /* NOTREACHED */
 394         }
 395
 396         switch (opmode) {
 397         case OM_COMPRESS:
 398                 if (argc > 2) {
 399                         vndcompress(argv[0], argv[1], strtoul(argv[2], &ep, 10));
 400                 } else {
 401                         vndcompress(argv[0], argv[1], DEF_BLOCKSIZE);
 402                 }
 403                 break;
 404
 405         case OM_UNCOMPRESS:
 406                 vnduncompress(argv[0], argv[1]);
 407                 break;
 408         }
 409
 410         exit(EXIT_SUCCESS);
 411 }