Return to zunzip.c CVS log

Up to [PGP] / pgp / src

Annotation of pgp/src/zunzip.c, revision 1.1

1.1     ! root        1: /*---------------------------------------------------------------------------
        !             2: 
        !             3:   unzip.c
        !             4: 
        !             5:   Highly butchered minimum unzip code for inflate.c
        !             6: 
        !             7:   ---------------------------------------------------------------------------*/
        !             8: 
        !             9: #include "zunzip.h"              /* includes, defines, and macros */
        !            10: 
        !            11: #define VERSION  "v4.20p BETA of 2-18-92"
        !            12: 
        !            13: /**********************/
        !            14: /*  Global Variables  */
        !            15: /**********************/
        !            16: 
        !            17: longint csize;        /* used by list_files(), ReadByte(): must be signed */
        !            18: longint ucsize;       /* used by list_files(), unReduce(), unImplode() */
        !            19: 
        !            20: ULONG mask_bits[] =
        !            21: {0x00000000L,
        !            22:  0x00000001L, 0x00000003L, 0x00000007L, 0x0000000fL,
        !            23:  0x0000001fL, 0x0000003fL, 0x0000007fL, 0x000000ffL,
        !            24:  0x000001ffL, 0x000003ffL, 0x000007ffL, 0x00000fffL,
        !            25:  0x00001fffL, 0x00003fffL, 0x00007fffL, 0x0000ffffL,
        !            26:  0x0001ffffL, 0x0003ffffL, 0x0007ffffL, 0x000fffffL,
        !            27:  0x001fffffL, 0x003fffffL, 0x007fffffL, 0x00ffffffL,
        !            28:  0x01ffffffL, 0x03ffffffL, 0x07ffffffL, 0x0fffffffL,
        !            29:  0x1fffffffL, 0x3fffffffL, 0x7fffffffL, 0xffffffffL};
        !            30: 
        !            31: /*---------------------------------------------------------------------------
        !            32:     Input file variables:
        !            33:   ---------------------------------------------------------------------------*/
        !            34: 
        !            35: byte *inbuf = NULL, *inptr;     /* input buffer (any size is legal) and pointer */
        !            36: int incnt;
        !            37: 
        !            38: ULONG bitbuf;
        !            39: int bits_left;
        !            40: boolean zipeof;
        !            41: 
        !            42: int zipfd;               /* zipfile file handle */
        !            43: 
        !            44: /*---------------------------------------------------------------------------
        !            45:     Output stream variables:
        !            46:   ---------------------------------------------------------------------------*/
        !            47: 
        !            48: byte *outbuf;                   /* buffer for rle look-back */
        !            49: byte *outptr;
        !            50: byte *outout;                   /* scratch pad for ASCII-native trans */
        !            51: longint outpos;                 /* absolute position in outfile */
        !            52: int outcnt;                     /* current position in outbuf */
        !            53: int outfd;
        !            54: 
        !            55: /*---------------------------------------------------------------------------
        !            56:     unzip.c static global variables (visible only within this file):
        !            57:   ---------------------------------------------------------------------------*/
        !            58: 
        !            59: static byte *hold;
        !            60: 
        !            61: /*******************/
        !            62: /* Main unzip code */
        !            63: /*******************/
        !            64: 
        !            65: int unzip( FILE *inFile, FILE *outFile )        /* return PK-type error code (except under VMS) */
        !            66: {
        !            67:        outfd = fileno( outFile );
        !            68:        zipfd = fileno( inFile );
        !            69: 
        !            70:        if( inbuf == NULL )
        !            71:                {
        !            72:                inbuf = (byte *) (malloc(INBUFSIZ + 4));    /* 4 extra for hold[] (below) */
        !            73:                outbuf = (byte *) (malloc(OUTBUFSIZ + 1));  /* 1 extra for string termin. */
        !            74:                outout = outbuf;        /*  else just point to outbuf */
        !            75: 
        !            76:                if ((inbuf == NULL) || (outbuf == NULL) || (outout == NULL)) {
        !            77:                        fprintf(stderr, "error:  can't allocate unzip buffers\n");
        !            78:                        RETURN(4);              /* 4-8:  insufficient memory */
        !            79:                }
        !            80:                hold = &inbuf[INBUFSIZ];    /* to check for boundary-spanning signatures */
        !            81:                }
        !            82: 
        !            83:        bits_left = 0;
        !            84:        bitbuf = 0;
        !            85:        outpos = 0L;
        !            86:        outcnt = 0;
        !            87:        outptr = outbuf;
        !            88:        zipeof = 0;
        !            89: 
        !            90:        /* Set output buffer to initial value */
        !            91:        memset(outbuf, 0, OUTBUFSIZ);
        !            92: 
        !            93:        /* Go from high- to low-level I/O */
        !            94:        lseek( zipfd, ftell(inFile), SEEK_SET );
        !            95: 
        !            96:        if ((incnt = read(zipfd,inbuf,INBUFSIZ)) <= 0) {
        !            97:                fprintf(stderr, "error: unexpected end if input");
        !            98:                return(-1);               /*  can still do next file   */
        !            99:                }
        !           100:        inptr = inbuf;
        !           101: 
        !           102:        /* Read in implode information */
        !           103:        csize = 1000L;                  /* Dummy size just to get input bits */
        !           104: 
        !           105:        /* Get compressed, uncompressed file sizes */
        !           106:        csize = ucsize = 1000000000L;   /* Make sure we can read in anything */
        !           107:        inflate();              /* Ftoomschk! */
        !           108: 
        !           109:        /* Flush output buffer before returning */
        !           110:        FlushOutput();
        !           111:        return(0);
        !           112: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.