#include "stdafx.h"
#pragma hdrstop

/*
  Common.cpp - common definitions and functions
************************************************************************
 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 "common.h"
#include "cpyrght.h"
#include "dz_errs.h"

#undef _DZ_FILE_
#define _DZ_FILE_ DZ_COMMON_CPP
                                      

int __fastcall Close_Handle(HANDLE *h)
{
    HANDLE ht = *h;

    if (ht != INVALID_HANDLE_VALUE)
    {
        *h = INVALID_HANDLE_VALUE;
        return CloseHandle(ht);
	}
    return 0;
}

__int64 SetFilePointer64(HANDLE hf, __int64 ofs, int from)
{
    typedef union
    {
        __int64 i64;

        struct
        {
            unsigned lo;
            int hi;
        };
    }_I64;

    _I64 o;
    o.i64 = ofs;
    o.lo = SetFilePointer(hf, o.lo, (LONG*) & o.hi, from);

    if (o.lo == INVALID_SET_FILE_POINTER  && GetLastError())
        return -1;

    return o.i64;
}

void Cleanup_Process(void)
{
// nothing to do
}

DWORD __fastcall GetFileAttrs(const TCHAR *p)
{
    WIN32_FIND_DATA fdata;
    HANDLE          fh;
    DWORD           ret = -1; // no_file indicator

    fh = FindFirstFile(p, &fdata);

    if (fh != INVALID_HANDLE_VALUE)
    {
        ret = fdata.dwFileAttributes;
        FindClose(fh);
    }

    return ret;
}

// Return the Unix time_t value (GMT/UTC time) for the DOS format (local)
//   time dostime, where dostime is a four byte value (date in most significant
//   word, time in least significant word), see dostime() function. dostime ::
//   DOS time to convert.
time_t dos2unixtime(ulg dostime)
{

    struct tm     *t;             // argument for mktime()
    const time_t  clock = time(NULL);

    t = localtime(&clock);

    // Convert DOS time to UNIX time_t format
    t->tm_sec = (((int)dostime) << 1) & 0x3E;
    t->tm_min = (((int)dostime) >> 5) & 0x3F;
    t->tm_hour = (((int)dostime) >> 11) & 0x1F;
    t->tm_mday = (int)(dostime >> 16) & 0x1F;
    t->tm_mon = ((int)(dostime >> 21) & 0x0F) - 1;
    t->tm_year = ((int)(dostime >> 25) & 0x7F) + 80;

    return mktime(t);
}

// Convert the date y/n/d and time h:m:s to a four byte DOS date and time
//   (date in high two bytes, time in low two bytes allowing magnitude
//   comparison). y :: Year. n :: Month. d :: Day. h :: Hour. m :: Minute. s ::
//   Second.
ulg dostime(int y, int n, int d, int h, int m, int s)
{
    return y < 1980 ? dostime(1980, 1, 1, 0, 0, 0) : (((ulg) y - 1980) << 25) |
           ((ulg) n << 21) | ((ulg) d << 16) | ((ulg) h << 11) | ((ulg) m << 5) |
           ((ulg) s >> 1);
}

// Return the Unix time t in DOS format, rounded up to the next two second
//   boundary. t :: Unix time to convert.
ulg unix2dostime(time_t *t)
{
    time_t    t_even;

    struct tm *s;                 // result of localtime()
    t_even = (*t + 1) & (~1); // Round up to even seconds.
    s = localtime(&t_even);     // Use local time since MSDOS does.

    if (s)
    {
        // Russell Peters s can be null
        return dostime(s->tm_year + 1900, s->tm_mon + 1, s->tm_mday, s->tm_hour, s->tm_min,
                       s->tm_sec);
    }

    return dostime(1980, 1, 1, 0, 0, 1);
}

char * __fastcall zstrdupB(const char* from)
{
    int len = strlen(from);
    if (!len)
        return NULL;
    char *tmp = new char[len+1];
    strcpy(tmp, from);
    tmp[len] = 0;
    return tmp;
}                                      

TCHAR * __fastcall zstrdup(const TCHAR* from)
{
    int len = _tcslen(from);
    if (!len)
        return NULL;
    TCHAR *tmp = new TCHAR[len+1];
    _tcscpy(tmp, from);
    tmp[len] = 0;
    return tmp;
}


const unsigned char* __fastcall FindTag(WORD tag, const unsigned char *p, unsigned &siz)
{
#pragma pack(push, 1)
union XTAG
{
	struct
	{
		unsigned short tg;
		unsigned short sz;
	};
	unsigned xtag;
}xtg;
#pragma pack(pop)

	if (!p || siz < sizeof(XTAG))
		return NULL;
	const unsigned char *e = p + siz - 1;
    while (p + 3 < e)
	{
		xtg = *((const XTAG*)p)++;
		if (xtg.tg == tag)
		{
			siz = xtg.sz;
			return p;
		}
		p += xtg.sz;
    }
    return NULL;
}