Beispiel #1
0
BOOL CopyCheck(
    CHAR        *pchPath,
    FILENAME    *fnCurrent
) {
    WORD        wFatDate;
    WORD        wFatTime;
    WORD        wDATFatDate;
    WORD        wDATFatTime;
    BOOL        b;

    if ( fnCurrent->dwDATFileSizeLow != fnCurrent->dwFileSizeLow ) {
        return( TRUE );
    }
    if ( fnCurrent->dwDATFileSizeHigh != fnCurrent->dwFileSizeHigh ) {
        return( TRUE );
    }
    b = FileTimeToDosDateTime( &fnCurrent->ftDATFileTime, &wDATFatDate, &wDATFatTime );
    if ( !b ) {
        return( TRUE );
    }
    b = FileTimeToDosDateTime( &fnCurrent->ftFileTime, &wFatDate, &wFatTime );
    if ( !b ) {
        return( TRUE );
    }

    if ( wDATFatTime != wFatTime ) {
        return( TRUE );
    }
    if ( wDATFatDate != wFatDate ) {
        return( TRUE );
    }
    return( FALSE );
}
Beispiel #2
0
static INT_PTR CDECL fci_get_open_info( char *name, USHORT *date, USHORT *time,
                                        USHORT *attribs, int *err, void *ptr )
{
    HANDLE handle;
    BY_HANDLE_FILE_INFORMATION info;
    WCHAR *p, *nameW = strdupAtoW( CP_UTF8, name );

    handle = CreateFileW( nameW, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
                          NULL, OPEN_EXISTING, 0, NULL );
    if (handle == INVALID_HANDLE_VALUE)
    {
        *err = GetLastError();
        WINE_ERR( "failed to open %s: error %u\n", wine_dbgstr_w(nameW), *err );
        cab_free( nameW );
        return -1;
    }
    if (!GetFileInformationByHandle( handle, &info ))
    {
        *err = GetLastError();
        CloseHandle( handle );
        cab_free( nameW );
        return -1;
    }
    FileTimeToDosDateTime( &info.ftLastWriteTime, date, time );
    *attribs = info.dwFileAttributes & (_A_RDONLY | _A_HIDDEN | _A_SYSTEM | _A_ARCH);
    for (p = nameW; *p; p++) if (*p >= 0x80) break;
    if (*p) *attribs |= _A_NAME_IS_UTF;
    cab_free( nameW );
    return (INT_PTR)handle;
}
Beispiel #3
0
DOS_TIME
DateTimeFile(
    LPSTR DirName,
    LPSTR FileName
    )
{
    char path[ DB_MAX_PATH_LENGTH ] = { 0 };
    WIN32_FIND_DATA FindFileData;
    HDIR FindHandle;
    DOS_TIME FileDateTime;

    if (DirName == NULL || DirName[0] == '\0') {
        FindHandle = FindFirstFile( FileName, &FindFileData );
    } else {
        sprintf( path, "%s" PATH_SEPARATOR "%s", DirName, FileName );
        FindHandle = FindFirstFile( path, &FindFileData );
    }

    if (FindHandle == (HDIR)INVALID_HANDLE_VALUE) {
        FileDateTime.value = 0;
    } else {
        FindClose( FindHandle );
        FileDateTime.value = 0;
        FileTimeToDosDateTime( &FindFileData.ftLastWriteTime,
                               &FileDateTime.time.wDate,
                               &FileDateTime.time.wTime
                             );
    }
    return( FileDateTime );
}
Beispiel #4
0
static FNFCIGETOPENINFO(cb_getopeninfo)
{
    BY_HANDLE_FILE_INFORMATION bhfi;
    FILETIME filetime;
    HANDLE handle;

    /* Need Win32 handle to get time stamps */
    handle = CreateFile(pszName, GENERIC_READ, FILE_SHARE_READ, NULL,
        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (handle == INVALID_HANDLE_VALUE)
        return -1;

    if (GetFileInformationByHandle(handle, &bhfi) == FALSE)
    {
        CloseHandle(handle);
        return -1;
    }

    FileTimeToLocalFileTime(&bhfi.ftLastWriteTime, &filetime);
    FileTimeToDosDateTime(&filetime, pdate, ptime);

    *pattribs = (int)(bhfi.dwFileAttributes &
        (_A_RDONLY | _A_SYSTEM | _A_HIDDEN | _A_ARCH));

    CloseHandle(handle);

    return _open(pszName, _O_RDONLY | _O_BINARY | O_NOINHERIT);
}
Beispiel #5
0
DWORD
WINAPI
demFileFindNext(OUT PVOID lpFindFileData)
{
    WIN32_FIND_DATAA FindData;
    PDOS_FIND_FILE_BLOCK FindFileBlock = (PDOS_FIND_FILE_BLOCK)lpFindFileData;

    do
    {
        if (!FindNextFileA(FindFileBlock->SearchHandle, &FindData))
            return GetLastError();

        /* Update the block */
        FindFileBlock->Attributes = LOBYTE(FindData.dwFileAttributes);
        FileTimeToDosDateTime(&FindData.ftLastWriteTime,
                              &FindFileBlock->FileDate,
                              &FindFileBlock->FileTime);
        FindFileBlock->FileSize = FindData.nFileSizeHigh ? 0xFFFFFFFF
                                                         : FindData.nFileSizeLow;
        strcpy(FindFileBlock->FileName, FindData.cAlternateFileName);
    }
    while((FindData.dwFileAttributes & (FILE_ATTRIBUTE_HIDDEN |
                                        FILE_ATTRIBUTE_SYSTEM |
                                        FILE_ATTRIBUTE_DIRECTORY))
          & ~FindFileBlock->AttribMask);

    return ERROR_SUCCESS;
}
int main()
{
    DWORD r;
    HANDLE pl;
    PROCESSENTRY32 pe;
    HANDLE stdout = GetStdHandle(STD_OUTPUT_HANDLE);

    WriteFile(stdout, title, lstrlen(title), &r, NULL);
    pl = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    pe.dwSize = sizeof(PROCESSENTRY32);
    pe.th32ParentProcessID = 0;

    if (Process32First(pl, &pe)) do {
        int hour;
        int minute;
        WORD fatdate;
        WORD fattime;
        HANDLE p = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pe.th32ProcessID);
        FILETIME cr;
        FILETIME ex;
        FILETIME kt;
        FILETIME ut;
        GetProcessTimes(p, &cr, &ex, &kt, &ut);
        FileTimeToDosDateTime(&cr, &fatdate, &fattime);
        hour = (fattime & 0xf800) >> 11;
        minute = (fattime & 0x07e0) >> 5;
        wsprintf(buf,"%08X %08X %2d:%02d %s\n", pe.th32ProcessID, pe.th32ParentProcessID, hour, minute, pe.szExeFile);
        WriteFile(stdout, buf, lstrlen(buf), &r, NULL);
        CloseHandle(p);
        pe.th32ParentProcessID = 0;
  } while (Process32Next(pl, &pe));

  CloseHandle(pl);
}
Beispiel #7
0
/****************************************************************************
*
*                            Open Watcom Project
*
*    Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved.
*
*  ========================================================================
*
*    This file contains Original Code and/or Modifications of Original
*    Code as defined in and that are subject to the Sybase Open Watcom
*    Public License version 1.0 (the 'License'). You may not use this file
*    except in compliance with the License. BY USING THIS FILE YOU AGREE TO
*    ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is
*    provided with the Original Code and Modifications, and is also
*    available at www.sybase.com/developer/opensource.
*
*    The Original Code and all software distributed under the License are
*    distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
*    EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM
*    ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF
*    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR
*    NON-INFRINGEMENT. Please see the License for the specific language
*    governing rights and limitations under the License.
*
*  ========================================================================
*
* Description:  WHEN YOU FIGURE OUT WHAT THIS FILE DOES, PLEASE
*               DESCRIBE IT HERE!
*
****************************************************************************/


#include "variety.h"
#include "widechar.h"
#include <stdio.h>
#include <string.h>
#include <direct.h>
#include <windows.h>
#include "libwin32.h"
#include "ntex.h"

#ifndef __WIDECHAR__    /* same for wide char, so only compile this once */
void __MakeDOSDT( FILETIME *NT_stamp, unsigned short *d, unsigned short *t )
{
    FILETIME local_ft;

    FileTimeToLocalFileTime( NT_stamp, &local_ft );
    FileTimeToDosDateTime( &local_ft, d, t );
}
Beispiel #8
0
static INT_PTR CDECL get_open_info(char *pszName, USHORT *pdate, USHORT *ptime,
                                   USHORT *pattribs, int *err, void *pv)
{
    BY_HANDLE_FILE_INFORMATION finfo;
    FILETIME filetime;
    HANDLE handle;
    DWORD attrs;
    BOOL res;

    handle = CreateFile(pszName, GENERIC_READ, FILE_SHARE_READ, NULL,
                        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);

    ok(handle != INVALID_HANDLE_VALUE, "Failed to CreateFile %s\n", pszName);

    res = GetFileInformationByHandle(handle, &finfo);
    ok(res, "Expected GetFileInformationByHandle to succeed\n");
   
    FileTimeToLocalFileTime(&finfo.ftLastWriteTime, &filetime);
    FileTimeToDosDateTime(&filetime, pdate, ptime);

    attrs = GetFileAttributes(pszName);
    ok(attrs != INVALID_FILE_ATTRIBUTES, "Failed to GetFileAttributes\n");

    return (INT_PTR)handle;
}
Beispiel #9
0
uint NTTimeToDos(FILETIME *ft)
{
  WORD DosDate,DosTime;
  FILETIME ct;
  FileTimeToLocalFileTime(ft,&ct);
  FileTimeToDosDateTime(&ct,&DosDate,&DosTime);
  return(((uint)DosDate<<16)|DosTime);
}
Beispiel #10
0
//-----------------------------------------------------------------------------
// CZLib::AddFile
//
// Adds a file to the zip archive
//
BOOL CZLib::AddFile(string f_file)
{
   BOOL bReturn = FALSE;

   // Open file being added
   HANDLE hFile = NULL;
   hFile = CreateFile(f_file.c_str(), GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
   if (hFile)
   {
      // Get file creation date
      FILETIME       ft = CUtility::getLastWriteFileTime(f_file);
      zip_fileinfo   zi = {0};

      FileTimeToDosDateTime(
         &ft,                       // last write FILETIME
         ((LPWORD)&zi.dosDate)+1,   // dos date
         ((LPWORD)&zi.dosDate)+0);  // dos time

      // Trim path off file name
      string sFileName = f_file.substr(f_file.find_last_of(_T('\\')) + 1);

      // Start a new file in Zip
      if (ZIP_OK == zipOpenNewFileInZip(m_zf, 
                                        sFileName.c_str(), 
                                        &zi, 
                                        NULL, 
                                        0, 
                                        NULL, 
                                        0, 
                                        NULL, 
                                        Z_DEFLATED, 
                                        Z_BEST_COMPRESSION))
      {
         // Write file to Zip in 4 KB chunks 
         const DWORD BUFFSIZE    = 4096;
         TCHAR buffer[BUFFSIZE]  = _T("");
         DWORD dwBytesRead       = 0;

         while (ReadFile(hFile, &buffer, BUFFSIZE, &dwBytesRead, NULL)
                && dwBytesRead)
         {
            if (ZIP_OK == zipWriteInFileInZip(m_zf, buffer, dwBytesRead)
               && dwBytesRead < BUFFSIZE)
            {
               // Success
               bReturn = TRUE;
            }
         }

         bReturn &= (ZIP_OK == zipCloseFileInZip(m_zf));
      }
      
      bReturn &= CloseHandle(hFile);
   }

   return bReturn;
}
Beispiel #11
0
uLong filetime(const char *filename, tm_zip *tmzip, uLong *dostime)
{
    int ret = 0;
#ifdef _WIN32
    FILETIME ftLocal;
    HANDLE hFind;
    WIN32_FIND_DATAA ff32;

    hFind = FindFirstFileA(filename, &ff32);
    if (hFind != INVALID_HANDLE_VALUE)
    {
        FileTimeToLocalFileTime(&(ff32.ftLastWriteTime), &ftLocal);
        FileTimeToDosDateTime(&ftLocal,((LPWORD)dostime)+1,((LPWORD)dostime)+0);
        FindClose(hFind);
        ret = 1;
    }
#else
#if defined unix || defined __APPLE__
    struct stat s = {0};
    struct tm* filedate;
    time_t tm_t = 0;

    if (strcmp(filename,"-") != 0)
    {
        char name[MAXFILENAME+1];
        size_t len = strlen(filename);
        if (len > MAXFILENAME)
            len = MAXFILENAME;

        strncpy(name, filename, MAXFILENAME - 1);
        name[MAXFILENAME] = 0;

        if (name[len - 1] == '/')
            name[len - 1] = 0;

        /* not all systems allow stat'ing a file with / appended */
        if (stat(name,&s) == 0)
        {
            tm_t = s.st_mtime;
            ret = 1;
        }
    }

    filedate = localtime(&tm_t);

    tmzip->tm_sec  = filedate->tm_sec;
    tmzip->tm_min  = filedate->tm_min;
    tmzip->tm_hour = filedate->tm_hour;
    tmzip->tm_mday = filedate->tm_mday;
    tmzip->tm_mon  = filedate->tm_mon ;
    tmzip->tm_year = filedate->tm_year;
#endif
#endif
    return ret;
}
static void pc_get_system_date(DATESTR * pd)
{
#ifdef RTFS_WINDOWS
	/* Windows runtime provides rotuines specifically for this purpose */
    SYSTEMTIME systemtime;
    FILETIME filetime;

    GetLocalTime(&systemtime);
    SystemTimeToFileTime(&systemtime, &filetime);
    FileTimeToDosDateTime(&filetime, &pd->date, &pd->time);
#else
    word  year;     /* relative to 1980 */
    word  month;    /* 1 - 12 */
    word  day;      /* 1 - 31 */
    word  hour;
    word  minute;
    word  sec;      /* Note: seconds are 2 second/per. ie 3 == 6 seconds */

#ifdef RTFS_LINUX
#define USE_ANSI_TIME 1	  /* Linux supports it */
#else
#define USE_ANSI_TIME 0   /* Enable if your runtime environment supports ansi time functions */
#endif
#if (USE_ANSI_TIME)
	{ /* Use ansi time functions. */
    struct tm *timeptr;
    time_t timer;

    time(&timer);
    timeptr = localtime(&timer);

    hour    =   (word) timeptr->tm_hour;
    minute  =   (word) timeptr->tm_min;
    sec =   (word) (timeptr->tm_sec/2);
    /* Date comes back relative to 1900 (eg 93). The pc wants it relative to
        1980. so subtract 80 */
    year  = (word) (timeptr->tm_year-80);
    month = (word) (timeptr->tm_mon+1);
    day   = (word) timeptr->tm_mday;
	}
#else /* In not windows and not using ansi time functions use hardwired values. */
    /* Modify this code if you have a clock calendar chip and can retrieve the values from that device instead */
    hour = 19;    /* 7:37:28 PM */
    minute = 37;
    sec = 14;
    /* 3-28-2008 */
    year  = 18;       /* relative to 1980 */
    month = 3;      /* 1 - 12 */
    day   = 28;       /* 1 - 31 */
#endif
    pd->time = (word) ( (hour << 11) | (minute << 5) | sec);
    pd->date = (word) ( (year << 9) | (month << 5) | day);
#endif /* #ifdef WINDOWS #else */

}
Beispiel #13
0
int GetFileDateTime(int filehandle, FILETIMESTRUCT *ftstruct)
{
	FILETIME filetime;
	int retval;

	retval = GetFileTime((HANDLE)filehandle, NULL, NULL, &filetime);
	if (retval) {
		FileTimeToDosDateTime(&filetime, &ftstruct->date, &ftstruct->time);
		return 0;
	}
	else return 1;
}
Beispiel #14
0
DWORD
WINAPI
demFileFindFirst(OUT PVOID  lpFindFileData,
                 IN  LPCSTR FileName,
                 IN  WORD   AttribMask)
{
    BOOLEAN Success = TRUE;
    WIN32_FIND_DATAA FindData;
    HANDLE SearchHandle;
    PDOS_FIND_FILE_BLOCK FindFileBlock = (PDOS_FIND_FILE_BLOCK)lpFindFileData;

    /* Start a search */
    SearchHandle = FindFirstFileA(FileName, &FindData);
    if (SearchHandle == INVALID_HANDLE_VALUE) return GetLastError();

    do
    {
        /* Check the attributes and retry as long as we haven't found a matching file */
        if (!((FindData.dwFileAttributes & (FILE_ATTRIBUTE_HIDDEN |
                                            FILE_ATTRIBUTE_SYSTEM |
                                            FILE_ATTRIBUTE_DIRECTORY))
             & ~AttribMask))
        {
            break;
        }
    }
    while ((Success = FindNextFileA(SearchHandle, &FindData)));

    /* If we failed at some point, close the search and return an error */
    if (!Success)
    {
        FindClose(SearchHandle);
        return GetLastError();
    }

    /* Fill the block */
    FindFileBlock->DriveLetter  = DosData->Sda.CurrentDrive + 'A';
    FindFileBlock->AttribMask   = AttribMask;
    FindFileBlock->SearchHandle = SearchHandle;
    FindFileBlock->Attributes   = LOBYTE(FindData.dwFileAttributes);
    FileTimeToDosDateTime(&FindData.ftLastWriteTime,
                          &FindFileBlock->FileDate,
                          &FindFileBlock->FileTime);
    FindFileBlock->FileSize = FindData.nFileSizeHigh ? 0xFFFFFFFF
                                                     : FindData.nFileSizeLow;
    /* Build a short path name */
    if (*FindData.cAlternateFileName)
        strncpy(FindFileBlock->FileName, FindData.cAlternateFileName, sizeof(FindFileBlock->FileName));
    else
        GetShortPathNameA(FindData.cFileName, FindFileBlock->FileName, sizeof(FindFileBlock->FileName));

    return ERROR_SUCCESS;
}
static bool mzGetFileTime(const std::string &filename,
                          tm_zip *tmzip, uLong *dostime)
{
    // Don't fail when building with -Werror
    (void) filename;
    (void) tmzip;
    (void) dostime;

#ifdef _WIN32
    FILETIME ftLocal;
    HANDLE hFind;
    WIN32_FIND_DATAW ff32;

    std::wstring wFilename = utf8::utf8ToUtf16(filename);
    hFind = FindFirstFileW(wFilename.c_str(), &ff32);
    if (hFind != INVALID_HANDLE_VALUE)
    {
        FileTimeToLocalFileTime(&ff32.ftLastWriteTime, &ftLocal);
        FileTimeToDosDateTime(&ftLocal,
                              ((LPWORD) dostime) + 1,
                              ((LPWORD) dostime) + 0);
        FindClose(hFind);
        return true;
    } else {
        FLOGE("%s: FindFirstFileW() failed: %s",
              filename.c_str(), win32ErrorToString(GetLastError()).c_str());
    }
#elif defined unix || defined __APPLE__ || defined __ANDROID__
    struct stat sb;
    struct tm t;

    if (stat(filename.c_str(), &sb) == 0) {
        time_t mtime = sb.st_mtime;
        if (!localtime_r(&mtime, &t)) {
            LOGE("localtime() failed");
            return false;
        }

        tmzip->tm_sec  = t.tm_sec;
        tmzip->tm_min  = t.tm_min;
        tmzip->tm_hour = t.tm_hour;
        tmzip->tm_mday = t.tm_mday;
        tmzip->tm_mon  = t.tm_mon ;
        tmzip->tm_year = t.tm_year;

        return true;
    } else {
        FLOGE("%s: stat() failed: %s", filename.c_str(), strerror(errno));
    }
#endif
    return false;
}
Beispiel #16
0
//
// MakeTimeString
//
static void MakeTimeString(FILETIME time, LPTSTR str)
{
    WORD d, t;

    str[0] = _T('\0');
   
    if(FileTimeToLocalFileTime(&time, &time) &&
       FileTimeToDosDateTime(&time, &d, &t))
    {
       wsprintf(str, _T("%d/%d/%d %02d:%02d:%02d"),
                (d / 32) & 15, d & 31, d / 512 + 1980,
                t >> 11, (t >> 5) & 0x3F, (t & 0x1F) * 2);
    }
static bool get_file_time(const std::string &filename, uint32_t *dostime)
{
    // Don't fail when building with -Werror
    (void) filename;
    (void) dostime;

#ifdef _WIN32
    FILETIME ft_local;
    HANDLE h_find;
    WIN32_FIND_DATAW ff32;

    auto w_filename = utf8_to_wcs(filename);
    if (!w_filename) {
        return false;
    }

    h_find = FindFirstFileW(w_filename.value().c_str(), &ff32);

    if (h_find != INVALID_HANDLE_VALUE)
    {
        FileTimeToLocalFileTime(&ff32.ftLastWriteTime, &ft_local);
        FileTimeToDosDateTime(&ft_local,
                              reinterpret_cast<LPWORD>(dostime) + 1,
                              reinterpret_cast<LPWORD>(dostime) + 0);
        FindClose(h_find);
        return true;
    } else {
        LOGE("%s: FindFirstFileW() failed: %s",
             filename.c_str(), ec_from_win32().message().c_str());
    }
#elif defined unix || defined __APPLE__ || defined __ANDROID__
    struct stat sb;
    struct tm t;

    if (stat(filename.c_str(), &sb) == 0) {
        time_t mtime = sb.st_mtime;
        if (!localtime_r(&mtime, &t)) {
            LOGE("localtime() failed");
            return false;
        }

        *dostime = tm_to_dosdate(&t);

        return true;
    } else {
        LOGE("%s: stat() failed: %s", filename.c_str(), strerror(errno));
    }
#endif
    return false;
}
Beispiel #18
0
static void test_FileTimeToDosDateTime(void)
{
    FILETIME ft = { 0 };
    WORD fatdate, fattime;
    BOOL ret;

    if (0)
    {
        /* Crashes */
        FileTimeToDosDateTime(NULL, NULL, NULL);
    }
    /* Parameter checking */
    SetLastError(0xdeadbeef);
    ret = FileTimeToDosDateTime(&ft, NULL, NULL);
    ok(!ret, "expected failure\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER,
       "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());

    SetLastError(0xdeadbeef);
    ret = FileTimeToDosDateTime(&ft, &fatdate, NULL);
    ok(!ret, "expected failure\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER,
       "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());

    SetLastError(0xdeadbeef);
    ret = FileTimeToDosDateTime(&ft, NULL, &fattime);
    ok(!ret, "expected failure\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER,
       "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());

    SetLastError(0xdeadbeef);
    ret = FileTimeToDosDateTime(&ft, &fatdate, &fattime);
    ok(!ret, "expected failure\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER,
       "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
}
static void PrintTime(char *output, FILETIME TimeToPrint)
{
	WORD Date, Time;
	if (FileTimeToLocalFileTime(&TimeToPrint, &TimeToPrint) &&
				FileTimeToDosDateTime(&TimeToPrint, &Date, &Time))
	{
		// What a silly way to print out the file date/time. Oh well,
		// it works, and I'm not aware of a cleaner way to do it.
		wsprintf(output, "%d/%d/%d %02d:%02d:%02d",
					(Date / 32) & 15, Date & 31, (Date / 512) + 1980,
					(Time / 2048), (Time / 32) & 63, (Time & 31) * 2);
	}
	else
		output[0] = 0;
}
Beispiel #20
0
//---------------------------------------------------------------------------
DWORD __fastcall TFile::GetDosTime(void)
{
  DWORD dos = 0L;
  FILETIME CT, LAT, LWT, NORMAL;
  if( ! handle ) return dos;
  Error = ! GetFileTime(handle, &CT, &LAT, &LWT);
  FileTimeToLocalFileTime(&LWT, &NORMAL);

  //FileTimeToDosDateTime(&CT, ((LPWORD)&dos)+1, (LPWORD)&dos);
  //FileTimeToDosDateTime(&LAT, ((LPWORD)&dos)+1, (LPWORD)&dos);
  FileTimeToDosDateTime(&NORMAL, ((LPWORD)&dos)+1, (LPWORD)&dos);

  if( Exceptions && Error ) throw 0;
  return dos;
}
Beispiel #21
0
uLong filetime(const char *f, tm_zip *tmzip, uLong *dt)
{
  int ret = 0;

  FILETIME ftLocal;
  HANDLE hFind;
  WIN32_FIND_DATA  ff32;
	FILETIME tmp;

  hFind = FindFirstFile(f,&ff32);
  if (hFind != INVALID_HANDLE_VALUE)
  {
    FileTimeToLocalFileTime(&(ff32.ftLastWriteTime),&ftLocal);
    FileTimeToDosDateTime(&ftLocal,((LPWORD)dt)+1,((LPWORD)dt)+0);
    FindClose(hFind);
    ret = 1;
  } else {
		GetSystemTimeAsFileTime(&tmp);
		FileTimeToLocalFileTime(&tmp,&ftLocal);
    FileTimeToDosDateTime(&ftLocal,((LPWORD)dt)+1,((LPWORD)dt)+0);
	}

  return ret;
}
Beispiel #22
0
uLong PackerJob::getFileTime(wchar_t *file, tm_zip*, uLong *dt)
{
	FILETIME ftLocal;
	HANDLE hFind;
	WIN32_FIND_DATA ff32;

	hFind = FindFirstFile(file, &ff32);
	if (hFind != INVALID_HANDLE_VALUE) {
		FileTimeToLocalFileTime(&(ff32.ftLastWriteTime), &ftLocal);
		FileTimeToDosDateTime(&ftLocal, ((LPWORD)dt) + 1, ((LPWORD)dt) + 0);
		FindClose(hFind);
		return 1;
	}

	return 0;
}
Beispiel #23
0
DOS_TIME
DateTimeFile2(
    LPSTR DirName,
    LPSTR FileName
    )
{
    char path[ DB_MAX_PATH_LENGTH ];
    WIN32_FILE_ATTRIBUTE_DATA FileData;
    DOS_TIME FileDateTime;
    BOOL rc;

    if (DirName == NULL || DirName[0] == '\0') {
        strcpy( path, FileName );
    } else {
        sprintf( path, "%s" PATH_SEPARATOR "%s", DirName, FileName );
    }

    rc = (*pGetFileAttributesExA) (path, GetFileExInfoStandard, (LPVOID)&FileData);

    if (!rc) {
        FileDateTime.value = 0;
    } else {
        FILETIME ftSystemTime;
        unsigned __int64 ui64Local, ui64File;
        GetSystemTimeAsFileTime(&ftSystemTime);

        ui64Local = (((unsigned __int64) ftSystemTime.dwHighDateTime) << 32) +
                      (unsigned __int64) ftSystemTime.dwLowDateTime;

        ui64File = (((unsigned __int64) FileData.ftLastWriteTime.dwHighDateTime) << 32) +
                     (unsigned __int64) FileData.ftLastWriteTime.dwLowDateTime;

        // Take into account that file times may have two second intervals (0x989680 = 1 second)
        // for FAT drives.
        if (ui64File > (ui64Local + (0x989680*2))) {
            BuildError("ERROR - \"%s\" file time is in the future.\n", path);
        }

        FileDateTime.value = 0L;
        FileTimeToDosDateTime( &FileData.ftLastWriteTime,
                               &FileDateTime.time.wDate,
                               &FileDateTime.time.wTime
                             );
    }
    return( FileDateTime );
}
Beispiel #24
0
long GetTheFileTime(char *name)
{
HANDLE h;
FILETIME ft, lft;
WORD dh, dl;

  h = CreateFile(name, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  if ( h != INVALID_HANDLE_VALUE ) {
    GetFileTime(h, NULL, NULL, &ft);
    FileTimeToLocalFileTime( &ft, &lft);
    FileTimeToDosDateTime( &lft, &dh, &dl);
    CloseHandle(h);
    return(dh<<16) | dl;
  }
  else
    return 0L;
}
Beispiel #25
0
uLong filetime(WCHAR *filename,tm_zip *tmzip, uLong *dt)
{
    int ret=0;
    {
        FILETIME ftLocal;
        HANDLE hFind;
        WIN32_FIND_DATAW ff32;

        hFind=FindFirstFileW(filename,&ff32);
        if (hFind != INVALID_HANDLE_VALUE)
        {
            FileTimeToLocalFileTime(&(ff32.ftLastWriteTime),&ftLocal);
            FileTimeToDosDateTime(&ftLocal,((LPWORD)dt)+1,((LPWORD)dt)+0);
            FindClose(hFind);
            ret=1;
        }
    }
    return ret;
}
Beispiel #26
0
static bool mzGetFileTime(const std::string &filename,
                          tm_zip *tmzip, uLong *dostime)
{
    // Don't fail when building with -Werror
    (void) filename;
    (void) tmzip;
    (void) dostime;

#ifdef _WIN32
    FILETIME ftLocal;
    HANDLE hFind;
    WIN32_FIND_DATAA ff32;

    hFind = FindFirstFileA(filename.c_str(), &ff32);
    if (hFind != INVALID_HANDLE_VALUE)
    {
        FileTimeToLocalFileTime(&ff32.ftLastWriteTime, &ftLocal);
        FileTimeToDosDateTime(&ftLocal,
                              ((LPWORD) dostime) + 1,
                              ((LPWORD) dostime) + 0);
        FindClose(hFind);
        return true;
    }
#elif defined unix || defined __APPLE__ /* || defined __ANDROID__ */
    struct stat sb;
    struct tm *t;

    if (stat(filename.c_str(), &sb) == 0) {
        t = localtime(&sb.st_mtime);

        tmzip->tm_sec  = t->tm_sec;
        tmzip->tm_min  = t->tm_min;
        tmzip->tm_hour = t->tm_hour;
        tmzip->tm_mday = t->tm_mday;
        tmzip->tm_mon  = t->tm_mon ;
        tmzip->tm_year = t->tm_year;

        return true;
    }
#endif
    return false;
}
Beispiel #27
0
DWORD
WINAPI
demFileFindFirst(OUT PVOID  lpFindFileData,
                 IN  LPCSTR FileName,
                 IN  WORD   AttribMask)
{
    BOOLEAN Success = TRUE;
    WIN32_FIND_DATAA FindData;
    PDOS_FIND_FILE_BLOCK FindFileBlock = (PDOS_FIND_FILE_BLOCK)lpFindFileData;

    /* Fill the block */
    FindFileBlock->DriveLetter  = CurrentDrive + 'A';
    FindFileBlock->AttribMask   = AttribMask;
    FindFileBlock->SearchHandle = FindFirstFileA(FileName, &FindData);
    if (FindFileBlock->SearchHandle == INVALID_HANDLE_VALUE) return GetLastError();

    do
    {
        /* Check the attributes */
        if (!((FindData.dwFileAttributes & (FILE_ATTRIBUTE_HIDDEN |
                                            FILE_ATTRIBUTE_SYSTEM |
                                            FILE_ATTRIBUTE_DIRECTORY))
            & ~AttribMask))
        {
            break;
        }
    }
    while ((Success = FindNextFileA(FindFileBlock->SearchHandle, &FindData)));

    if (!Success) return GetLastError();

    FindFileBlock->Attributes = LOBYTE(FindData.dwFileAttributes);
    FileTimeToDosDateTime(&FindData.ftLastWriteTime,
                          &FindFileBlock->FileDate,
                          &FindFileBlock->FileTime);
    FindFileBlock->FileSize = FindData.nFileSizeHigh ? 0xFFFFFFFF
                                                     : FindData.nFileSizeLow;
    strcpy(FindFileBlock->FileName, FindData.cAlternateFileName);

    return ERROR_SUCCESS;
}
Beispiel #28
0
uLong filetime(
    const char *f,              /* name of file to get info on */
    tm_zip *tmzip,        /* return value: access, modific. and creation times */
    uLong *dt             /* dostime */  )
{
  int ret = 0;
  {
      FILETIME ftLocal;
      HANDLE hFind;
      WIN32_FIND_DATAA ff32;

      hFind = FindFirstFileA(f,&ff32);
      if (hFind != INVALID_HANDLE_VALUE)
      {
        FileTimeToLocalFileTime(&(ff32.ftLastWriteTime),&ftLocal);
        FileTimeToDosDateTime(&ftLocal,((LPWORD)dt)+1,((LPWORD)dt)+0);
        FindClose(hFind);
        ret = 1;
      }
  }
  return ret;
}
Beispiel #29
0
/*
========================
idZipBuilder::GetFileTime
========================
*/
bool idZipBuilder::GetFileTime( const idStr& filename, unsigned long* dostime ) const
{
	// RB: FIXME
#if defined(_WIN32)
	{
		FILETIME filetime;
		WIN32_FIND_DATA fileData;
		HANDLE			findHandle = FindFirstFile( filename.c_str(), &fileData );
		if( findHandle != INVALID_HANDLE_VALUE )
		{
			FileTimeToLocalFileTime( &( fileData.ftLastWriteTime ), &filetime );
			FileTimeToDosDateTime( &filetime, ( ( LPWORD )dostime ) + 1, ( ( LPWORD )dostime ) + 0 );
			FindClose( findHandle );
			return true;
		}
		FindClose( findHandle );
	}
#endif
	// RB end
	
	return false;
}
Beispiel #30
0
const zip_fileinfo* setFileInfo(zip_fileinfo* fi, unsigned long long itemFiletime)
{
    const zip_fileinfo* fip;
    if (itemFiletime == 0)
    {
        fip = 0;
    }
    else
    {
        filetime64_t filetime = {itemFiletime};
        FILETIME localFileTime;
        FileTimeToLocalFileTime(&filetime.ft, &localFileTime);
        unsigned short dosDate;
        unsigned short dosTime;
        FileTimeToDosDateTime(&localFileTime, &dosDate, &dosTime);
        memset(fi, 0, sizeof(*fi));
        fi->dosDate = (static_cast<unsigned long>(dosDate) << 16) | dosTime;
        fip = fi;
    }

    return fip;
}