util.c

GZip Compress Souce Code

/* util.c -- utility functions for gzip support
 * Copyright (C) 1992-1993 Jean-loup Gailly
 * This is free software; you can redistribute it and/or modify it under the
 * terms of the GNU General Public License, see the file COPYING.
 */

#ifdef RCSID
static char rcsid[] = "$Id: util.c,v 0.15 1993/06/15 09:04:13 jloup Exp $";
#endif

#include <ctype.h>
#include <errno.h>
#include <sys/types.h>

#include "tailor.h"

#ifdef HAVE_UNISTD_H
#  include <unistd.h>
#endif
#ifndef NO_FCNTL_H
#  include <fcntl.h>
#endif

#if defined(STDC_HEADERS) || !defined(NO_STDLIB_H)
#  include <stdlib.h>
#else
   extern int errno;
#endif

#include "gzip.h"
#include "crypt.h"

#include "bsdebug.h"
//#define _DEBUG_UTIL_C_
#ifdef DBGPrintfi
#undef DBGPrintfi
#endif
#ifdef DBGPrintfo
#undef DBGPrintfo
#endif

#if defined(_TRACEHELPER_DEBUG_ALL_)
  #define DBGPrintfi(a) DbgPrintfi a;
  #define DBGPrintfo(a) DbgPrintfo a;
#elif defined(_DEBUG_UTIL_C_) && defined(_TRACEHELPER_DEBUG_EACH_OF_FILE_)
  #define DBGPrintfi(a) DbgPrintfi a;
  #define DBGPrintfo(a) DbgPrintfo a;
#else
  #define DBGPrintfi(a)
  #define DBGPrintfo(a)
#endif


extern ulg crc_32_tab[];   /* crc table, defined below */

/* ===========================================================================
 * Copy input to output unchanged: zcat == cat with --force.
 * IN assertion: insize bytes have already been read in inbuf.
 */
int copy(in, out)
    int in, out;   /* input and output file descriptors */
{
  DBGPrintfi(("copy(In)\r\n"));
  {
    errno = 0;
    while (insize != 0 && (int)insize != EOF) {
	write_buf(out, (char*)inbuf, insize);
	bytes_out += insize;
	insize = read(in, (char*)inbuf, INBUFSIZ);
    }
    if ((int)insize == EOF && errno != 0) {
		read_error();
		DBGPrintfo(("copy(out10)\r\n"));
		return -1;
    }
    bytes_in = bytes_out;
    
    DBGPrintfo(("copy(out1)\r\n"));
    return  OK;

  }
}

/* ===========================================================================
 * Run a set of bytes through the crc shift register.  If s is a NULL
 * pointer, then initialize the crc shift register contents instead.
 * Return the current crc in either case.
 */
ulg updcrc(s, n)
    uch *s;                 /* pointer to bytes to pump through */
    unsigned n;             /* number of bytes in s[] */
{
  DBGPrintfi(("updcrc(In)\r\n"));
  {
    register ulg c;         /* temporary variable */

    static ulg crc = (ulg)0xffffffffL; /* shift register contents */

    if (s == NULL) {
	c = 0xffffffffL;
    } else {
	c = crc;
        if (n) do {
            c = crc_32_tab[((int)c ^ (*s++)) & 0xff] ^ (c >> 8);
        } while (--n);
    }
    crc = c;
    
    DBGPrintfo(("updcrc(out1)\r\n"));
    return  c ^ 0xffffffffL;       /* (instead of ~c for 64-bit machines) */

  }
}

/* ===========================================================================
 * Clear input and output buffers
 */
void clear_bufs()
{
  DBGPrintfi(("clear_bufs(In)\r\n"));
  {
    outcnt = 0;
    insize = inptr = 0;
    bytes_in = bytes_out = 0L;

  }
  DBGPrintfo(("clear_bufs(out)\r\n"));
}

extern char *in_buf;
extern int in_size;
extern int in_rd_count;

/* ===========================================================================
 * Fill the input buffer. This is called only when the buffer is empty.
 */
// by bskim
int fill_inbuf(eof_ok)
    int eof_ok;          /* set if EOF acceptable as a result */
{
  DBGPrintfi(("fill_inbuf(In)\r\n"));
  {
    int len;

    /* Read as much as possible */
    insize = 0;
    errno = 0;

	if ( in_size > in_rd_count)
		len = in_size - in_rd_count;
	else
		len = 0;

	if ( len > INBUFSIZ)
	{
		len = INBUFSIZ;
	}

	memcpy(inbuf, &in_buf[in_rd_count], len);
	insize = len;

    if (insize == 0) {
      	 DBGPrintfo(("fill_inbuf(out1)\r\n"));
       	 return  EOF; 
    }

	in_rd_count += insize;
    bytes_in += (ulg)insize;
    inptr = 1;
    
    DBGPrintfo(("fill_inbuf(out2)\r\n"));
    return  inbuf[0];

  }
}

#if 0
int fill_inbuf(eof_ok)
    int eof_ok;          /* set if EOF acceptable as a result */
{
  DBGPrintfi(("fill_inbuf(In)\r\n"));
  {
    int len;

    /* Read as much as possible */
    insize = 0;
    errno = 0;
    do {
	len = read(ifd, (char*)inbuf+insize, INBUFSIZ-insize);
        if (len == 0 || len == EOF) break;
	insize += len;
    } while (insize < INBUFSIZ);

    if (insize == 0) {
	if (eof_ok) { 
            	 DBGPrintfo(("fill_inbuf(out1)\r\n"));
            	 return  EOF; 
            	}
	read_error();
    }
    bytes_in += (ulg)insize;
    inptr = 1;
    
    DBGPrintfo(("fill_inbuf(out2)\r\n"));
    return  inbuf[0];

  }
}
#endif

extern char *out_buf;
extern int out_buf_size;
extern int *out_size;
extern int *outUnitSize;
extern char **pout;
/* ===========================================================================
 * Write the output buffer outbuf[0..outcnt-1] and update bytes_out.
 * (used for the compressed data only)
 */

void flush_outbuf()
{
  DBGPrintfi(("flush_outbuf(In)\r\n"));
  {
	char *tbuf;
	int size1, size2;

	if ( !*pout )
	{
		*pout = out_buf = (char *)xmalloc(OUTBUFSIZ+sizeof(char*));			
		if (out_buf == 0)		return;
		*((char **)&out_buf[OUTBUFSIZ]) = 0;
		*out_size = 0;
		out_buf_size = OUTBUFSIZ;
		*outUnitSize = OUTBUFSIZ;
	}

    if (outcnt == 0) { 
                      DBGPrintfo(("flush_outbuf(out1)\r\n"));
                      return ; 
                     }

	if ( (*out_size+outcnt) > out_buf_size )
	{
		while(outcnt>0)
		{
			size1 = out_buf_size - *out_size;
			memcpy(&out_buf[*out_size - (out_buf_size - OUTBUFSIZ)], outbuf, size1);

			tbuf = (char *)xmalloc(OUTBUFSIZ+sizeof(char*));
			if (tbuf == 0)		return;
			*((char **)&tbuf[OUTBUFSIZ]) = 0;
			*((char **)&out_buf[OUTBUFSIZ]) = tbuf;
			out_buf = tbuf;

			size2 = outcnt - size1;
			if ( size2 > OUTBUFSIZ )		size2 = OUTBUFSIZ;
			memcpy(&out_buf[0], &outbuf[size1], size2);
			
			out_buf_size += OUTBUFSIZ;
			*out_size += (size1+size2); 
			outcnt -= (size1+size2);
		}
	}
	else
	{
		memcpy(&out_buf[*out_size], outbuf, outcnt);
		*out_size += outcnt;
	}
    
    bytes_out += (ulg)outcnt;
    outcnt = 0;

  }
  DBGPrintfo(("flush_outbuf(out)\r\n"));
}

#if 0
void flush_outbuf()
{
  DBGPrintfi(("flush_outbuf(In)\r\n"));
  {
    if (outcnt == 0) { 
                      DBGPrintfo(("flush_outbuf(out1)\r\n"));
                      return ; 
                     }

    write_buf(ofd, (char *)outbuf, outcnt);
    bytes_out += (ulg)outcnt;
    outcnt = 0;

  }
  DBGPrintfo(("flush_outbuf(out)\r\n"));
}
#endif

/* ===========================================================================
 * Write the output window window[0..outcnt-1] and update crc and bytes_out.
 * (Used for the decompressed data only.)
 */
// by bskim
void flush_window()
{
  DBGPrintfi(("flush_window(In)\r\n"));
  {
	char *tbuf;
	int size1, size2;

	if ( !*pout )
	{
		*pout = out_buf = (char *)xmalloc(WSIZE+sizeof(char*));
		if (out_buf==0) return;
		*((char **)&out_buf[WSIZE]) = 0;
		*out_size = 0;
		out_buf_size = WSIZE;
		*outUnitSize = WSIZE;
	}

	if (outcnt == 0) { 
                      DBGPrintfo(("flush_window(out1)\r\n"));
                      return ; 
                     }

    updcrc(window, outcnt);

	if ( (*out_size+outcnt) > out_buf_size)
	{
		while(outcnt>0)
		{
			size1 = out_buf_size - *out_size;
			memcpy(&out_buf[*out_size - (out_buf_size - WSIZE)], window, size1);

			tbuf = (char *)xmalloc(WSIZE+sizeof(char*));
			if (tbuf ==0) return;
			*((char **)&tbuf[WSIZE]) = 0;
			*((char **)&out_buf[WSIZE]) = tbuf;
			out_buf = tbuf;

			size2 = outcnt - size1;
			if ( size2 > WSIZE )		size2 = WSIZE;
			memcpy(&out_buf[0], &outbuf[size1], size2);
			
			out_buf_size += WSIZE;
			*out_size += (size1+size2); 
			outcnt -= (size1+size2);
		}
	}
	else
	{
		memcpy(&out_buf[*out_size], window, outcnt);
		*out_size += outcnt;
	}

    bytes_out += (ulg)outcnt;
    outcnt = 0;
  }
  DBGPrintfo(("flush_window(out)\r\n"));
}

#if 0
void flush_window()
{
  DBGPrintfi(("flush_window(In)\r\n"));
  {
    if (outcnt == 0) { 
                      DBGPrintfo(("flush_window(out1)\r\n"));
                      return ; 
                     }
    updcrc(window, outcnt);

    if (!test) {
	write_buf(ofd, (char *)window, outcnt);
    }
    bytes_out += (ulg)outcnt;
    outcnt = 0;

  }
  DBGPrintfo(("flush_window(out)\r\n"));
}
#endif

/* ===========================================================================
 * Does the same as write(), but also handles partial pipe writes and checks
 * for error return.
 */

void write_buf(fd, buf, cnt)
    int       fd;
    voidp     buf;
    unsigned  cnt;
{
  DBGPrintfi(("write_buf(In)\r\n"));
  {
  }
  DBGPrintfo(("write_buf(out)\r\n"));
}

#if 0
void write_buf(fd, buf, cnt)
    int       fd;
    voidp     buf;
    unsigned  cnt;
{
  DBGPrintfi(("write_buf(In)\r\n"));
  {
    unsigned  n;

    while ((n = write(fd, buf, cnt)) != cnt) {
	if (n == (unsigned)(-1)) {
	    write_error();
	}
	cnt -= n;