Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/usr.bin/vndcompress/vnduncompress.c

263 lines
8.2 KiB
C
Raw Blame History

/* $NetBSD: vnduncompress.c,v 1.14 2017/07/29 21:04:07 riastradh Exp $ */
/*-
* Copyright (c) 2013 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Taylor R. Campbell.
*
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
*/
#include <sys/cdefs.h>
__RCSID("$NetBSD: vnduncompress.c,v 1.14 2017/07/29 21:04:07 riastradh Exp $");
#include <sys/endian.h>
#include <assert.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <limits.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <zlib.h>
#include "common.h"
#include "offtab.h"
#include "utils.h"
static void err1(const char *, ...) __printflike(1,2) __dead;
static void errx1(const char *, ...) __printflike(1,2) __dead;
int
vnduncompress(int argc, char **argv, const struct options *O __unused)
{
struct offtab offtab;
if (argc != 2)
usage();
const char *const cloop2_pathname = argv[0];
const char *const image_pathname = argv[1];
/* Open the cloop2 and image files. */
const int cloop2_fd = open(cloop2_pathname, O_RDONLY);
if (cloop2_fd == -1)
err(1, "open(%s)", cloop2_pathname);
const int image_fd = open(image_pathname,
(O_WRONLY | O_CREAT | O_TRUNC), 0777);
if (image_fd == -1)
err(1, "open(%s)", image_pathname);
/* Read the header. */
struct cloop2_header header;
const ssize_t h_read = read_block(cloop2_fd, &header, sizeof(header));
if (h_read == -1)
err(1, "read header");
assert(h_read >= 0);
if ((size_t)h_read != sizeof(header))
errx(1, "partial read of header: %zu != %zu",
(size_t)h_read, sizeof(header));
const uint32_t blocksize = be32toh(header.cl2h_blocksize);
const uint32_t n_blocks = be32toh(header.cl2h_n_blocks);
/* Sanity-check the header parameters. */
__CTASSERT(MIN_BLOCKSIZE <= UINT32_MAX);
if (blocksize < MIN_BLOCKSIZE)
errx(1, "blocksize too small: %"PRIu32
" (must be at least %"PRIu32")",
blocksize, (uint32_t)MIN_BLOCKSIZE);
__CTASSERT(MAX_BLOCKSIZE <= UINT32_MAX);
if (MAX_BLOCKSIZE < blocksize)
errx(1, "blocksize too large: %"PRIu32
" (must be at most %"PRIu32")",
blocksize, (uint32_t)MAX_BLOCKSIZE);
__CTASSERT(DEV_BSIZE <= UINT32_MAX);
if ((blocksize % DEV_BSIZE) != 0)
errx(1, "bad blocksize: %"PRIu32
" (not a multiple of %"PRIu32")",
blocksize, (uint32_t)DEV_BSIZE);
__CTASSERT(MAX_N_BLOCKS <= UINT32_MAX);
if (MAX_N_BLOCKS < n_blocks)
errx(1, "too many blocks: %"PRIu32" (max %"PRIu32")",
n_blocks, (uint32_t)MAX_N_BLOCKS);
/* Calculate the number of offsets we'll have to handle. */
__CTASSERT(MAX_N_BLOCKS <= (UINT32_MAX - 1));
__CTASSERT((MAX_N_BLOCKS + 1) == MAX_N_OFFSETS);
const uint32_t n_offsets = (n_blocks + 1);
/* Choose a working window size. */
uint32_t window_size;
if (ISSET(O->flags, FLAG_w) && (O->window_size < n_offsets)) {
if (lseek(cloop2_fd, 0, SEEK_CUR) == -1) {
if (errno == ESPIPE)
errx(1, "window too small, nonseekable input");
else
err(1, "window too small and lseek failed");
}
window_size = O->window_size;
} else {
if (lseek(cloop2_fd, 0, SEEK_CUR) == -1) {
if (errno != ESPIPE)
warn("lseek");
window_size = 0;
} else {
window_size = DEF_WINDOW_SIZE;
}
}
/* Initialize the offset table and start reading it in. */
__CTASSERT(CLOOP2_OFFSET_TABLE_OFFSET <= OFFTAB_MAX_FDPOS);
offtab_init(&offtab, n_offsets, window_size, cloop2_fd,
CLOOP2_OFFSET_TABLE_OFFSET);
offtab_reset_read(&offtab, &err1, &errx1);
/* Allocate compression buffers. */
/* XXX compression ratio bound */
__CTASSERT(MUL_OK(size_t, 2, MAX_BLOCKSIZE));
void *const compbuf = malloc(2 * (size_t)blocksize);
if (compbuf == NULL)
err(1, "malloc compressed buffer");
__CTASSERT(MAX_BLOCKSIZE <= SIZE_MAX);
void *const uncompbuf = malloc(blocksize);
if (uncompbuf == NULL)
err(1, "malloc uncompressed buffer");
/*
* Uncompress the blocks.
*/
__CTASSERT(MUL_OK(off_t, MAX_N_OFFSETS, sizeof(uint64_t)));
__CTASSERT(ADD_OK(off_t, sizeof(header),
(MAX_N_OFFSETS * sizeof(uint64_t))));
__CTASSERT(OFF_MAX <= UINT64_MAX);
uint64_t offset = (sizeof(header) +
((uint64_t)n_offsets * sizeof(uint64_t)));
uint32_t blkno;
(void)offtab_prepare_get(&offtab, 0);
uint64_t last = offtab_get(&offtab, 0);
for (blkno = 0; blkno < n_blocks; blkno++) {
(void)offtab_prepare_get(&offtab, (blkno + 1));
const uint64_t start = last;
const uint64_t end = offtab_get(&offtab, (blkno + 1));
/* Sanity-check the offsets. */
if (start != offset)
errx(1, "strange offset for block %"PRIu32
": 0x%"PRIx64,
blkno, start);
/* XXX compression ratio bound */
__CTASSERT(MUL_OK(size_t, 2, MAX_BLOCKSIZE));
if ((2 * (size_t)blocksize) <= (end - start))
errx(1, "block %"PRIu32" too large"
": %"PRIu64" bytes from 0x%"PRIx64" to 0x%"PRIx64,
blkno, (end - start), start, end);
assert(offset <= MIN(OFF_MAX, UINT64_MAX));
if ((MIN(OFF_MAX, UINT64_MAX) - offset) < (end - start))
errx(1, "block %"PRIu32" overflows offset:"
" 0x%"PRIx64" + %"PRIu64,
blkno, offset, (end - start));
/* Read the compressed block. */
const ssize_t n_read = read_block(cloop2_fd, compbuf,
(end - start));
if (n_read == -1)
err(1, "read block %"PRIu32, blkno);
assert(n_read >= 0);
if ((size_t)n_read != (end - start))
errx(1, "partial read of block %"PRIu32": %zu != %zu",
blkno, (size_t)n_read, (size_t)(end - start));
/* Uncompress the block. */
const unsigned long complen = (end - start);
unsigned long uncomplen = blocksize;
const int zerror = uncompress(uncompbuf, &uncomplen, compbuf,
complen);
if (zerror != Z_OK)
errx(1, "block %"PRIu32" decompression failure (%d)"
": %s", blkno, zerror, zError(zerror));
/* Sanity-check the uncompressed length. */
assert(uncomplen <= blocksize);
if (((blkno + 1) < n_blocks) && (uncomplen != blocksize))
errx(1, "truncated non-final block %"PRIu32
": %lu bytes", blkno, uncomplen);
/* Write the uncompressed block. */
const ssize_t n_written = write(image_fd, uncompbuf,
uncomplen);
if (n_written == -1)
err(1, "write block %"PRIu32, blkno);
assert(n_written >= 0);
if ((size_t)n_written != uncomplen)
errx(1, "partial write of block %"PRIu32": %zu != %lu",
blkno, (size_t)n_written, uncomplen);
/* Advance our position. */
assert((size_t)n_read <= (MIN(OFF_MAX, UINT64_MAX) - offset));
offset += (size_t)n_read;
last = end;
}
/* Destroy the offset table and free the compression buffers. */
offtab_destroy(&offtab);
free(uncompbuf);
free(compbuf);
/* Close the files. */
if (close(image_fd) == -1)
warn("close(image fd)");
if (close(cloop2_fd) == -1)
warn("close(cloop2 fd)");
return 0;
}
static void __printflike(1,2) __dead
err1(const char *fmt, ...)
{
va_list va;
va_start(va, fmt);
verr(1, fmt, va);
va_end(va);
}
static void __printflike(1,2) __dead
errx1(const char *fmt, ...)
{
va_list va;
va_start(va, fmt);
verrx(1, fmt, va);
va_end(va);
}
Reference in New Issue View Git Blame Copy Permalink