/*      $NetBSD: cread.c,v 1.29 2023/06/14 00:28:55 rin 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)
*
* - replaces open(), close(), read(), lseek().
* - original libsa open(), close(), read(), lseek() are called
*   as oopen(), oclose(), oread() resp. olseek().
* - compression parts stripped from zlib:gzio.c
*/

/* 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
*/

#include "stand.h"
#ifdef _STANDALONE
#include <lib/libkern/libkern.h>
#include <lib/libz/libz.h>
#else
#include <string.h>
#include <zlib.h>
#endif

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

#ifdef SAVE_MEMORY
#define Z_BUFSIZE 1024
#else
#define Z_BUFSIZE 4096
#endif

static const 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 header file for these: */
void    *zcalloc(void *, unsigned int, unsigned int);
void    zcfree(void *, void *);
void    zmemcpy(unsigned char *, unsigned char *, unsigned int);

/*
* This is the double-loop version of LE CRC32 from if_ethersubr,
* lightly modified -- it is ~1KB smaller than libkern version with
* DYNAMIC_CRC_TABLE but too much slower especially on ancient poor CPUs.
*/
#ifndef ETHER_CRC_POLY_LE
#define ETHER_CRC_POLY_LE       0xedb88320
#endif
uint32_t
crc32(uint32_t crc, const uint8_t *const buf, size_t len)
{
#if defined(LIBSA_CREAD_NOCRC)
       /* XXX provide a stub to avoid pulling a larger libkern version */
       return crc;
#else
       uint32_t c, carry;
       size_t i, j;

       crc = 0xffffffffU ^ crc;
       for (i = 0; i < len; i++) {
               c = buf[i];
               for (j = 0; j < 8; j++) {
                       carry = ((crc & 0x01) ? 1 : 0) ^ (c & 0x01);
                       crc >>= 1;
                       c >>= 1;
                       if (carry) {
                               crc = (crc ^ ETHER_CRC_POLY_LE);
                       }
               }
       }
       return (crc ^ 0xffffffffU);
#endif /* defined(LIBSA_CREAD_NOCRC) */
}

/*
* compression utilities
*/

void *
zcalloc(void *opaque, unsigned int items, unsigned int size)
{

       return alloc(items * size);
}

void
zcfree(void *opaque, void *ptr)
{

       dealloc(ptr, 0); /* XXX works only with modified allocator */
}

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 = oread(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;
       int c;

       x  =  (unsigned long)get_byte(s);
       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
open(const char *fname, int mode)
{
       int fd;
       struct sd *s = 0;

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

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

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

       s->stream.next_in = s->inbuf = (unsigned char *)alloc(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)
               dealloc(s, sizeof(struct sd));
       ss[fd] = NULL;
       oclose(fd);
       return -1;
}

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

#if !defined(LIBSA_NO_FD_CHECKING)
       if ((unsigned int)fd >= SOPEN_MAX) {
               errno = EBADF;
               return -1;
       }
#endif

       s = ss[fd];

       if (s != NULL) {
               inflateEnd(&(s->stream));

               dealloc(s->inbuf, Z_BUFSIZE);
               dealloc(s, sizeof(struct sd));
       }

       return oclose(fd);
}

ssize_t
read(int fd, void *buf, size_t len)
{
       struct sd *s;
#if !defined(LIBSA_CREAD_NOCRC)
       unsigned char *start = buf; /* starting point for crc computation */
#endif

       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 = oread(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 = oread(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) {
                       uint32_t total_out;
#if !defined(LIBSA_CREAD_NOCRC)
                       uint32_t crc;
                       /* Check CRC and original size */
                       s->crc = crc32(s->crc, start, (unsigned int)
                                       (s->stream.next_out - start));
                       start = s->stream.next_out;
                       crc = getLong(s);
#else
                       (void)getLong(s);
#endif
                       total_out = getLong(s);

                       if (
#if !defined(LIBSA_CREAD_NOCRC)
                           crc != s->crc ||
#endif
                           total_out != 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));
#if !defined(LIBSA_CREAD_NOCRC)
                                       s->crc = crc32(0L, Z_NULL, 0);
#endif
                               }
                       }
               }
               if (s->z_err != Z_OK || s->z_eof)
                       break;
       }

#if !defined(LIBSA_CREAD_NOCRC)
       s->crc = crc32(s->crc, start,
                      (unsigned int)(s->stream.next_out - start));
#endif

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

off_t
lseek(int fd, off_t offset, int where)
{
       struct open_file *f;
       struct sd *s;

#if !defined(LIBSA_NO_FD_CHECKING)
       if ((unsigned int)fd >= SOPEN_MAX) {
               errno = EBADF;
               return -1;
       }
#endif
       f = &files[fd];

       if ((f->f_flags & F_READ) == 0)
               return olseek(fd, offset, where);

       s = ss[fd];

       if(s->compressed == 0) {
               off_t res = olseek(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;
               /* FALLTHROUGH */
       case SEEK_SET:
               /* if seek backwards, simply start from the beginning */
               if (offset < s->stream.total_out) {
                       off_t res;
                       void *sav_inbuf;

                       res = olseek(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 */
                       (void)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 (read(fd, dummybuf, len) != len) {
                                       errno = EOFFSET;
                                       return (off_t)-1;
                               }
                               toskip -= len;
                       }
               }
#ifdef DEBUG
               if (offset != s->stream.total_out)
                       panic("lseek compressed");
#endif
               return offset;
       case SEEK_END:
               errno = EOFFSET;
               break;
       default:
               errno = EINVAL;
               break;
       }

       return (off_t)-1;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.