#include "stdafx.h"
#pragma hdrstop
#include "dz_errs.h"

#undef _DZ_FILE_
#define _DZ_FILE_ DZ_UNZSS_CPP
/*
UnzSS.cpp -

  Copyright (c) 1990-2007 Info-ZIP.  All rights reserved.

  See the accompanying file LICENSE, version 2007-Mar-4 or later
  (the contents of which are also included in zip.h) for terms of use.
  If, for some reason, all these files are missing, the Info-ZIP license
  also may be found at:  ftp://ftp.info-zip.org/pub/infozip/license.html

  parts Copyright (C) 1997 Mike White, Eric W. Engler
************************************************************************
 Copyright (C) 2009, 2010  by Russell J. Peters, Roger Aelbrecht

   This file is part of TZipMaster Version 1.9.

    TZipMaster is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    TZipMaster is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with TZipMaster.  If not, see <http://www.gnu.org/licenses/>.

    contact: problems@delphizip.org (include ZipMaster in the subject).
    updates: http://www.delphizip.org
    DelphiZip maillist subscribe at http://www.freelists.org/list/delphizip 
************************************************************************/

#include "UnzOp.h"     
#include <stdio.h>

int UnzOpr::UnzStreamStream(void)
{
    CHdrInfo sinfo;
    fpInfo = &sinfo;
    int b, r;
    int error = 0;
    memset(&sinfo, 0, sizeof(CHdrInfo));
    fnewzip = true;
    InProgress = true;
    fBytesWritten = 0;
    ffilename = _T("0:<INSTREAM>");
//    STRCPY(ffilename, "<INSTREAM>");
    fUnzInfile = new ZStream(this, ffilename, fSS->fSSInput);
    AutoStream inz(&fUnzInfile);
    /*---------------------------------------------------------------------------
    *    Initialize variables, buffers, etc.
    *---------------------------------------------------------------------------*/
//  fcsize = 50028;
//  fcsize = 0x40000000000i64;
    fcsize = fSS->Size;
    fbits_left = 0;
    fbitbuf = 0L;
    /* unreduce and unshrink only */
    fzipeof = 0;
    fnewfile = true;
    fdisk_full = 0;
    fcrc32val = CRCVAL_INITIAL;
    defer_leftover_input();
    // so NEXTBYTE bounds check will work
    int method = fSS->Method & 0xff;

    if ((unsigned)fSS->Method > 0xFF)
    {
        if (Verbose < 0)
            Notify(ITRACE, _T("about to call decrypt"));

        Encrypted = true;

        if ((error = decrypt(fSS->CRC >> 24)) != PK_COOL)
		{
//			int cbe;
//            CB->Arg1 = 0;
//            CB->Arg2 = SKIPPED_BAD_PASSWORD;
//			cbe = CB->UserCB(zacSkipped, ffilename);

            if (Verbose < 0)
				Notify(ITRACE, _T("Skipping encrypted Stream, bad password"));

			if (Skipping(ffilename, error, SKIPPED_BAD_PASSWORD))
				Fatal(DZ_ERM_SKIPPED, 2);

			if (Abort_Flag)// || cbe == CALLBACK_TRUE)
				Fatal(DZ_ERM_ABORT, 0);

            return error;
        }
    }

    fBytesWritten = 0;

    CB->Arg1 = 1;
    CB->UserCB(zacCount);

    // Pass total filesize.
    CB->FileSize = fcsize;
    CB->UserCB(zacSize);
//    CBData.MsgP = "<UNDEFLATE>";
    CB->FileSize = fcsize;
    CB->UserCB(zacItem, _T("<undeflate>"));

    fUnzOutfile = new ZStream(this, _T("0:<OUTSTREAM>"), fSS->fSSOutput);
    AutoStream outz(&fUnzOutfile);

	switch (method)
    {

        case STORED:
            foutptr = Slide;
            foutcnt = 0L;

            while ((b = NEXTBYTE) != EOF && !fdisk_full)
            {
                * foutptr++ = (uch)b;

                if (++foutcnt == wsize)
                {
                    // EWE: wsize = 32K
                    flush(Slide, foutcnt, 0);
                    foutptr = Slide;
                    foutcnt = 0L;

                    if (Abort_Flag)
                    {
                        /* v1.6026 */
                        CloseOut();
                        undefer_input();
						Fatal(DZ_ERM_ABORT, 0);
                    }
                }
            }

            if (foutcnt) // flush final (partial) buffer
                flush(Slide, foutcnt, 0);

            break;

        case DEFLATED:

        case ENHDEFLATED:
        {
            if (Verbose < 0)
                Notify(ITRACE,  _T("about to call Inflate"));

            if ((r = inflate(method == ENHDEFLATED)) != 0)
            {
                int zerr = DZ_ERR(r);
            if (zerr != DZ_ERR(PK_WARN) && 
                (zerr == DZ_ERR(PK_BADERR) || zerr == DZ_ERR(PK_NOZIP) ||
				zerr == DZ_ERR(PK_FIND) || zerr == DZ_ERR(PK_EOF)))
                {
                    return r;
                }

                Notify(0, _T("Error unzipping files"));

                error = PK_ERR;
            }
            else
            {
                ffiles_acted_on++;
                fSS->CRC = fcrc32val;
            }
        }

        break;

        default:
            /* should never get to this point */

            if (Verbose)// < 0)
                Notify(ITRACE, _T("should NEVER get here"));

            Notify(0, _T("Error stream - unknown method"));

			/* close and delete file before return? */
            return PK_ERR;
    }

    /* end switch (compression method) */
    CB->UserCB(zacEndOfBatch); // done with stream extraction

    if (fdisk_full)
    {
        /* set by flush() */
        if (fdisk_full > 1)
        {
            return PK_DISKFULL;
        }

        error = PK_WARN;
    }

    if (PK_Rank(error) > PK_Rank(PK_WARN))
    {
        return error;
    }

    if (Verbose)
        Notify(IVERBOSE,  _T("stream of size %Lu %s"), fBytesWritten,
            ftflag ? _T("Tested  ") : _T("Unzipped"));

    if (error != PK_COOL && Verbose < 0)
        Notify(ITRACE, _T("UnzStreamStream returning error: %d"), error);

    return error;
}