/*	$NetBSD: cread.c,v 1.10 2009/03/31 11:48:15 tsutsui Exp $	*/

/*
 * Copyright (c) 1996
 *	Matthias Drochner.  All rights reserved.
 *
 * 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 AUTHOR ``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 AUTHOR 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.
 *
 */

/*
 * Support for compressed bootfiles  (only read)
 *
 * - provides copen(), cclose(), cread(), clseek().
 * - compression parts stripped from zlib:gzio.c
 * - copied from libsa with small modifications for my MiNT environment.
 *   Note that everything in the 'tostools' hierarchy is made to function
 *   in my local MiNT environment.
 */

/* gzio.c -- IO on .gz files
 * Copyright (C) 1995-1996 Jean-loup Gailly.
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

#define _CREAD_C	/* Turn of open/close/read redefines */

#include <unistd.h>
#include <string.h>
#include <memory.h>
#include <fcntl.h>
#include <errno.h>
#include <zlib.h>
#include <cread.h>

#define __P(proto)		proto
#define	SOPEN_MAX		1


#define EOF (-1) /* needed by compression code */

#ifdef SAVE_MEMORY
#define Z_BUFSIZE 1024
#else
#define Z_BUFSIZE 32*1024
#endif

static int gz_magic[2] = {0x1f, 0x8b};	/* gzip magic header */

/* gzip flag byte */
#define ASCII_FLAG	0x01	/* bit 0 set: file probably ascii text */
#define HEAD_CRC	0x02	/* bit 1 set: header CRC present */
#define EXTRA_FIELD	0x04	/* bit 2 set: extra field present */
#define ORIG_NAME	0x08	/* bit 3 set: original file name present */
#define COMMENT		0x10	/* bit 4 set: file comment present */
#define RESERVED	0xE0	/* bits 5..7: reserved */

static struct sd {
	z_stream	stream;
	int		z_err;	/* error code for last stream operation */
	int		z_eof;	/* set if end of input file */
	int		fd;
	unsigned char	*inbuf;	/* input buffer */
	unsigned long	crc;	/* crc32 of uncompressed data */
	int		compressed;	/* 1 if input file is a .gz file */
} *ss[SOPEN_MAX];

static int		get_byte(struct sd *);
static unsigned long	getLong(struct sd *);
static void		check_header(struct sd *);

/* XXX - find suitable headerf ile for these: */
void	*zcalloc(void *, unsigned int, unsigned int);
void	zcfree(void *, void *);
void	zmemcpy(unsigned char *, unsigned char *, unsigned int);


/*
 * compression utilities
 */

void *
zcalloc (void *opaque, unsigned items, unsigned size)
{
	return(malloc(items * size));
}

void
zcfree (void *opaque, void *ptr)
{
	free(ptr);
}

void
zmemcpy(unsigned char *dest, unsigned char *source, unsigned int len)
{
	memcpy(dest, source, len);
}

static int
get_byte(struct sd *s)
{
	if (s->z_eof)
		return (EOF);

	if (s->stream.avail_in == 0) {
		int got;

		errno = 0;
		got = cread(s->fd, s->inbuf, Z_BUFSIZE);
		if (got <= 0) {
			s->z_eof = 1;
			if (errno) s->z_err = Z_ERRNO;
			return EOF;
		}
		s->stream.avail_in = got;
		s->stream.next_in = s->inbuf;
	}
	s->stream.avail_in--;
	return *(s->stream.next_in)++;
}

static unsigned long
getLong (struct sd *s)
{
	unsigned long x = (unsigned long)get_byte(s);
	int c;

	x += ((unsigned long)get_byte(s)) << 8;
	x += ((unsigned long)get_byte(s)) << 16;
	c = get_byte(s);
	if (c == EOF)
		s->z_err = Z_DATA_ERROR;
	x += ((unsigned long)c)<<24;
	return x;
}

static void
check_header(struct sd *s)
{
	int method; /* method byte */
	int flags;  /* flags byte */
	unsigned int len;
	int c;

	/* Check the gzip magic header */
	for (len = 0; len < 2; len++) {
		c = get_byte(s);
		if (c == gz_magic[len])
			continue;
		if ((c == EOF) && (len == 0))  {
			/*
			 * We must not change s->compressed if we are at EOF;
			 * we may have come to the end of a gzipped file and be
			 * check to see if another gzipped file is concatenated
			 * to this one. If one isn't, we still need to be able
			 * to lseek on this file as a compressed file.
			 */
			return;
		}
		s->compressed = 0;
		if (c != EOF) {
			s->stream.avail_in++;
			s->stream.next_in--;
		}
		s->z_err = s->stream.avail_in != 0 ? Z_OK : Z_STREAM_END;
		return;
	}
	s->compressed = 1;
	method = get_byte(s);
	flags = get_byte(s);
	if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
		s->z_err = Z_DATA_ERROR;
		return;
	}

	/* Discard time, xflags and OS code: */
	for (len = 0; len < 6; len++)
		(void)get_byte(s);

	if ((flags & EXTRA_FIELD) != 0) {
		/* skip the extra field */
		len  =  (unsigned int)get_byte(s);
		len += ((unsigned int)get_byte(s)) << 8;
		/* len is garbage if EOF but the loop below will quit anyway */
		while (len-- != 0 && get_byte(s) != EOF) /*void*/;
	}
	if ((flags & ORIG_NAME) != 0) {
		/* skip the original file name */
		while ((c = get_byte(s)) != 0 && c != EOF) /*void*/;
	}
	if ((flags & COMMENT) != 0) {
		/* skip the .gz file comment */
		while ((c = get_byte(s)) != 0 && c != EOF) /*void*/;
	}
	if ((flags & HEAD_CRC) != 0) {  /* skip the header crc */
		for (len = 0; len < 2; len++)
			(void)get_byte(s);
	}
	s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
}

/*
 * new open(), close(), read(), lseek()
 */

int
copen(const char *fname, int mode)
{
	int fd;
	struct sd *s = 0;

	if ( ((fd = open(fname, mode)) == -1) || (mode != O_RDONLY) )
		/* compression only for read */
		return(fd);

	ss[fd] = s = malloc(sizeof(struct sd));
	if (s == 0)
		goto errout;
	memset(s, 0, sizeof(struct sd));

	if (inflateInit2(&(s->stream), -15) != Z_OK)
		goto errout;

	s->stream.next_in  = s->inbuf = (unsigned char*)malloc(Z_BUFSIZE);
	if (s->inbuf == 0) {
		inflateEnd(&(s->stream));
		goto errout;
	}

	s->fd = fd;
	check_header(s); /* skip the .gz header */
	return(fd);

errout:
	if (s != 0)
		free(s);
	close(fd);
	return (-1);
}

int
cclose(int fd)
{
	struct sd *s;

	s = ss[fd];

	inflateEnd(&(s->stream));

	free(s->inbuf);
	free(s);

	return (close(fd));
}

size_t
cread(int fd, void *buf, size_t len)
{
	struct sd *s;
	unsigned char *start = buf; /* starting point for crc computation */

	s = ss[fd];

	if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO)
		return (-1);
	if (s->z_err == Z_STREAM_END)
		return (0);  /* EOF */

	s->stream.next_out = buf;
	s->stream.avail_out = len;

	while (s->stream.avail_out != 0) {

		if (s->compressed == 0) {
			/* Copy first the lookahead bytes: */
			unsigned int n = s->stream.avail_in;
			if (n > s->stream.avail_out)
				n = s->stream.avail_out;
			if (n > 0) {
				zmemcpy(s->stream.next_out,
					s->stream.next_in, n);
				s->stream.next_out  += n;
				s->stream.next_in   += n;
				s->stream.avail_out -= n;
				s->stream.avail_in  -= n;
			}
			if (s->stream.avail_out > 0) {
				int got;
				got = read(s->fd, s->stream.next_out,
					    s->stream.avail_out);
				if (got == -1)
					return (got);
				s->stream.avail_out -= got;
			}
			return (int)(len - s->stream.avail_out);
		}

		if (s->stream.avail_in == 0 && !s->z_eof) {
			int got;
			errno = 0;
			got = read(fd, s->inbuf, Z_BUFSIZE);
			if (got <= 0) {
				s->z_eof = 1;
				if (errno) {
					s->z_err = Z_ERRNO;
					break;
				}
			}
			s->stream.avail_in = got;
			s->stream.next_in = s->inbuf;
		}

		s->z_err = inflate(&(s->stream), Z_NO_FLUSH);

		if (s->z_err == Z_STREAM_END) {
			/* Check CRC and original size */
			s->crc = crc32(s->crc, start, (unsigned int)
					(s->stream.next_out - start));
			start = s->stream.next_out;

			if (getLong(s) != s->crc ||
			    getLong(s) != s->stream.total_out) {

				s->z_err = Z_DATA_ERROR;
			} else {
				/* Check for concatenated .gz files: */
				check_header(s);
				if (s->z_err == Z_OK) {
					inflateReset(&(s->stream));
					s->crc = crc32(0L, Z_NULL, 0);
				}
			}
		}
		if (s->z_err != Z_OK || s->z_eof)
			break;
	}

	s->crc = crc32(s->crc, start,
		       (unsigned int)(s->stream.next_out - start));

	return (int)(len - s->stream.avail_out);
}

off_t
clseek(int fd, off_t offset, int where)
{
	struct sd *s;

	s = ss[fd];

	if(s->compressed == 0) {
		off_t res = lseek(fd, offset, where);
		if (res != (off_t)-1) {
			/* make sure the lookahead buffer is invalid */
			s->stream.avail_in = 0;
		}
		return (res);
	}

	switch(where) {
	case SEEK_CUR:
		    offset += s->stream.total_out;
	case SEEK_SET:
		/* if seek backwards, simply start from the beginning */
		if (offset < s->stream.total_out) {
			off_t res;
			void *sav_inbuf;

			res = lseek(fd, 0, SEEK_SET);
			if(res == (off_t)-1)
			    return(res);
			/* ??? perhaps fallback to close / open */

			inflateEnd(&(s->stream));

			sav_inbuf = s->inbuf; /* don't allocate again */
			memset(s, 0, sizeof(struct sd)); /* this resets total_out to 0! */

			inflateInit2(&(s->stream), -15);
			s->stream.next_in = s->inbuf = sav_inbuf;

			s->fd = fd;
			check_header(s); /* skip the .gz header */
		}

		    /* to seek forwards, throw away data */
		if (offset > s->stream.total_out) {
			off_t toskip = offset - s->stream.total_out;

			while (toskip > 0) {
#define DUMMYBUFSIZE 256
				char dummybuf[DUMMYBUFSIZE];
				off_t len = toskip;
				if (len > DUMMYBUFSIZE) len = DUMMYBUFSIZE;
				if (cread(fd, dummybuf, len) != len) {
					errno = EINVAL;
					return ((off_t)-1);
				}
				toskip -= len;
			}
		}
#ifdef DEBUG
		if (offset != s->stream.total_out)
			panic("lseek compressed");
#endif
		return (offset);
	case SEEK_END:
		errno = EINVAL;
		break;
	default:
		errno = EINVAL;
	}

	return((off_t)-1);
}
