#include "stdafx.h"
#pragma hdrstop

#include "common.h"
#include "DZOper.h"
#include "dz_errs.h"
#include "version.h"
#include <alloc.h>
#include <new>
#include <except.h>

#undef _DZ_FILE_
#define _DZ_FILE_ DZ_ENTER_CPP

/* enter.cpp

************************************************************************
 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 <alloc.H>
#ifndef MULTITHREAD
#error Multithread required
#endif

CRITICAL_SECTION csSync;
HINSTANCE ModuleInst = 0;
int UCount = 0;
int ZCount = 0;
unsigned int FCount = 0;
bool IsNTorAbove = false;
//---------------------------------------------------------------------------

/* =====================================================
* Entry point to abort operation started with C
*/
long WINAPI DZ_Abort(void * C)
{
    return Set_Oper_Abort((OperKeys)C);
}

static int IsOpFrame(DZFrame * p)
{
#if defined(__BORLANDC__) && (__BORLANDC__ < 0x0550)
    if (!p)
        return 0;
#else
    if (!p || std::heapchecknode(p) != _USEDENTRY)
        return 0;
#endif
    return p->IsME(p);
}

#if defined(ALLOW_WIN98) && defined(UNICODE)
extern int Init_Imports(void);
extern void FreeDLLs(void);
#endif

typedef void (*pvf)();
pvf OldTerm = 0;
pvf OldUnex = 0;

#pragma argsused
//int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void * lpReserved)
int WINAPI DllMain(HINSTANCE hinstDLL, DWORD fwdreason, LPVOID lpvReserved)
{
//  OutputDebugString("Entering DllEntryPoint ");
    switch (fwdreason)
    {

        case DLL_PROCESS_ATTACH:
            ModuleInst = hinstDLL;
            InitializeCriticalSection(&csSync);
            UCount = 0;
            ZCount = 0;
			FCount = 0;
#ifndef _ONLY_A
            IsNTorAbove = GetVersion() < 0x80000000;
#endif
#if defined(ALLOW_WIN98) && defined(UNICODE)
            if (IsNTorAbove)
                Init_Imports();
#endif
            // fall through

        case DLL_THREAD_ATTACH:
            break;

        case DLL_THREAD_DETACH:
            break;

        case DLL_PROCESS_DETACH:
            Cleanup_Process();
#if defined(ALLOW_WIN98) && defined(UNICODE)
            FreeDLLs();
#endif
            DeleteCriticalSection(&csSync);
    }

    return 1;
}

//---------------------------------------------------------------------------
void Set_Oper(DZFrame *Op, int typ)
{
    if (Op)
    {
        EnterCriticalSection(&csSync);

        if (Op->SetME(Op, typ))
        {
            if (typ == ZIPOPER)
                ZCount++;
            else
                UCount++;

            FCount++;
        }
        else
        {
            if (typ == ZIPOPER)
                ZCount--;
            else
                UCount--;
        }

        LeaveCriticalSection(&csSync);
    }
}


int Set_Oper_Abort(OperKeys key)
{
    int ret = 1;
    DZFrame *p = (DZFrame *)(key << 2);

#if defined(__BORLANDC__) && (__BORLANDC__ < 0x0550)
    if (!p)
        return -1;
#else
    if (!p || std::heapchecknode(p) != _USEDENTRY)
        return -1;
#endif

    EnterCriticalSection(&csSync);

    if (p->IsME(p))
    {
        if (p->Abort_Flag > GA_CANCEL)
            ret--;           // could not set it
        else
            p->Abort_Flag |= GA_ABORT;
    }

    LeaveCriticalSection(&csSync);

    return ret;
}

long WINAPI DZ_Version(void)
{
	return DZ_VER_VERSION; // see version.h
}

long WINAPI DZ_PrivVersion(void)
{
	return DZ_VER_PRIVATE;
}

char gbuf[MAX_PATH + 2];
const char* WINAPI DZ_Path(void)
{
	if (!GetModuleFileNameA(ModuleInst, gbuf, MAX_PATH))
	{
        gbuf[0] = 0;
    }

    return gbuf;
}

long WINAPI DZ_Name(void* buf, int bufsiz, int wide)
{
	if (wide)
		return GetModuleFileNameW(ModuleInst, (wchar_t*)buf, bufsiz);
	else
		return GetModuleFileNameA(ModuleInst, (char*)buf, bufsiz);
}

const char* WINAPI DZ_Banner(void)
{
	sprintf(gbuf, "%s.dll version %s, %s", DLLNAME, DZ_VER, __DATE__);
	return gbuf;
}

void KillpG(DZOp** ppG)
{
    if (ppG)
    {
        DZOp * tmp = *ppG;
        *ppG = NULL;
        delete tmp;
        OutputDebugString(L"killed pG");
    }
}

int xxfilter(EXCEPTION_POINTERS *);

// Add, update, freshen, move, or delete zip entries in a zip file.
long WINAPI DZ_Exec(const DllCommands * C)
{
	DZOp *pG = 0;
	long RetVal;

	// EXCEPTION_POINTERS *xp = 0;            // Marx Fix

	OutputDebugString(L"DZ_Exec enter");
	if (!C || C->fCheck != DLLCOMMANDCHECK)
	{
		// This Seven is at another place as in ZCL!
		return -DZ_ERR_STRUCT;
	}

	int cmd = C->fOptions.opts & 0xF;

	if (cmd != DLL_OPT_OpIsZip && cmd != DLL_OPT_OpIsDelete && cmd !=
		DLL_OPT_OpIsUnz && cmd != DLL_OPT_OpIsTest)
	{
		return -DZ_ERR_STRUCT;
	}

	try
	{
		if (cmd == DLL_OPT_OpIsZip || cmd == DLL_OPT_OpIsDelete)
			pG = MakeZipper(C);
		else
			pG = MakeUnzipper(C);

		if (!pG)
			throw DZFatalException(DZ_ERR_MEMORY);
		try
		{
			try
			{
				RetVal = pG->Init();
				if (!RetVal)
				{
					RetVal = pG->Exec(C);
					if (pG->Verbose < 0)
						pG->Notify(ITRACE, _T("RetVal = %d "), RetVal);
				}
			}
			catch(DZFatalException & E)
			{
				RetVal =  -DZ_ERR(E.ErrNo);
			}
			catch(std::bad_alloc)
			{
				RetVal =  -DZ_ERR_MEMORY;
			}
			catch(int X)
			{
				X = DZ_ERR(X);
				RetVal =  -X;
			}
			catch(...)
			{
				RetVal =  -DZ_ERR_ERROR;
			}
		}
		__finally
		{
			KillpG(&pG);
		}
	}
	__except (xxfilter(/* xp = */ GetExceptionInformation()))  // Marx Fix
    {
         RetVal = -DZ_ERR_ERROR;
    }

    OutputDebugString(L"DZ_Exec done");
    return RetVal;
}

int xxfilter(EXCEPTION_POINTERS * xp)
{
    int rc = EXCEPTION_CONTINUE_SEARCH;  // default - give up

    EXCEPTION_RECORD *xr = xp->ExceptionRecord;
//    CONTEXT *xc = xp->ContextRecord;
    switch (xr->ExceptionCode) {
        case STATUS_INTEGER_DIVIDE_BY_ZERO:
        case EXCEPTION_ACCESS_VIOLATION:
            rc = EXCEPTION_EXECUTE_HANDLER;
//            break;
    };
    return rc;
}