BOOL WINAPI DosDateTimeToFileTime( WORD fatdate, WORD fattime, LPFILETIME ft) {
struct tm newtm;
#ifndef HAVE_TIMEGM
struct tm *gtm;
time_t time1, time2;
#endif
TRACEN((printf("DosDateTimeToFileTime\n")))
newtm.tm_sec = (fattime & 0x1f) * 2;
newtm.tm_min = (fattime >> 5) & 0x3f;
newtm.tm_hour = (fattime >> 11);
newtm.tm_mday = (fatdate & 0x1f);
newtm.tm_mon = ((fatdate >> 5) & 0x0f) - 1;
newtm.tm_year = (fatdate >> 9) + 80;
#ifdef HAVE_TIMEGM
TRACEN((printf("DosDateTimeToFileTime-1\n")))
RtlSecondsSince1970ToFileTime( timegm(&newtm), ft );
#else
TRACEN((printf("DosDateTimeToFileTime-2\n")))
time1 = mktime(&newtm);
gtm = gmtime(&time1);
time2 = mktime(gtm);
RtlSecondsSince1970ToFileTime( 2*time1-time2, ft );
#endif
return TRUE;
}
bool CFindFile::FindFirst(CFSTR cfWildcard, CFileInfo &fi, bool ignoreLink)
{
if (!Close())
return false;
AString Awildcard = UnicodeStringToMultiByte(cfWildcard, CP_ACP);
const char * wildcard = (const char *)Awildcard;
if ((!wildcard) || (wildcard[0]==0)) {
SetLastError(ERROR_PATH_NOT_FOUND);
return false;
}
my_windows_split_path(nameWindowToUnix(wildcard),_directory,_pattern);
TRACEN((printf("CFindFile::FindFirst : %s (dirname=%s,pattern=%s)\n",wildcard,(const char *)_directory,(const char *)_pattern)))
_dirp = ::opendir((const char *)_directory);
TRACEN((printf("CFindFile::FindFirst : opendir=%p\n",_dirp)))
if ((_dirp == 0) && (global_use_utf16_conversion)) {
// Try to recover the original filename
UString ustr = MultiByteToUnicodeString(_directory, 0);
AString resultString;
bool is_good = originalFilename(ustr, resultString);
if (is_good) {
_dirp = ::opendir((const char *)resultString);
_directory = resultString;
}
}
if (_dirp == 0) return false;
struct dirent *dp;
while ((dp = readdir(_dirp)) != NULL) {
if (filter_pattern(dp->d_name,(const char *)_pattern,0) == 1) {
int retf = fillin_CFileInfo(fi,(const char *)_directory,dp->d_name,ignoreLink);
if (retf)
{
TRACEN((printf("CFindFile::FindFirst : closedir-1(dirp=%p)\n",_dirp)))
closedir(_dirp);
_dirp = 0;
SetLastError( ERROR_NO_MORE_FILES );
return false;
}
TRACEN((printf("CFindFile::FindFirst -%s- true\n",dp->d_name)))
return true;
}
}
BOOL WINAPI DosDateTimeToFileTime( WORD fatdate, WORD fattime, FILETIME * ft)
{
struct tm newtm;
#ifndef ENV_HAVE_TIMEGM
struct tm *gtm;
time_t time1, time2;
#endif
TRACEN((printf("DosDateTimeToFileTime\n")))
newtm.tm_sec = (fattime & 0x1f) * 2;
newtm.tm_min = (fattime >> 5) & 0x3f;
newtm.tm_hour = (fattime >> 11);
newtm.tm_mday = (fatdate & 0x1f);
newtm.tm_mon = ((fatdate >> 5) & 0x0f) - 1;
newtm.tm_year = (fatdate >> 9) + 80;
newtm.tm_isdst = -1;
#ifdef ENV_HAVE_TIMEGM
RtlSecondsSince1970ToFileTime( timegm(&newtm), ft );
#else
newtm.tm_isdst = 0;
time1 = mktime(&newtm);
gtm = gmtime(&time1);
time2 = mktime(gtm);
RtlSecondsSince1970ToFileTime( 2*time1-time2, ft );
#endif
TRACEN((printf("DosDateTimeToFileTime(%ld,%ld) => %lx %lx\n",
(long)fatdate,(long)fattime,
(long)ft->dwHighDateTime,(long)ft->dwLowDateTime)))
return TRUE;
}
BOOL WINAPI FileTimeToDosDateTime( const FILETIME *ft, WORD *fatdate, WORD *fattime ) {
LARGE_INTEGER li;
ULONG t;
time_t unixtime;
struct tm* tm;
WORD fat_d,fat_t;
TRACEN((printf("FileTimeToDosDateTime\n")))
li.QuadPart = ft->dwHighDateTime;
li.QuadPart = (li.QuadPart << 32) | ft->dwLowDateTime;
RtlTimeToSecondsSince1970( &li, &t );
unixtime = t; /* unixtime = t; * FIXME unixtime = t - TIME_GetBias(); */
tm = gmtime( &unixtime );
fat_t = (tm->tm_hour << 11) + (tm->tm_min << 5) + (tm->tm_sec / 2);
fat_d = ((tm->tm_year - 80) << 9) + ((tm->tm_mon + 1) << 5) + tm->tm_mday;
if (fattime)
*fattime = fat_t;
if (fatdate)
*fatdate = fat_d;
TRACEN((printf("FileTimeToDosDateTime : %lx %lx => %d %d\n",
(long)ft->dwHighDateTime,(long)ft->dwLowDateTime,(unsigned)fat_d,(unsigned)fat_t)))
return TRUE;
}
static inline NTSTATUS WINAPI RtlLocalTimeToSystemTime( const LARGE_INTEGER *LocalTime,
LARGE_INTEGER *SystemTime) {
TRACEN((printf("RtlLocalTimeToSystemTime\n")))
LONG bias = TIME_GetBias();
SystemTime->QuadPart = LocalTime->QuadPart + bias * (LONGLONG)TICKSPERSEC;
return STATUS_SUCCESS;
}
/***********************************************************************
* NtQuerySystemTime [NTDLL.@]
* ZwQuerySystemTime [NTDLL.@]
*
* Get the current system time.
*
* PARAMS
* Time [O] Destination for the current system time.
*
* RETURNS
* Success: STATUS_SUCCESS.
* Failure: An NTSTATUS error code indicating the problem.
*/
NTSTATUS WINAPI NtQuerySystemTime( LARGE_INTEGER *Time ) {
struct timeval now;
TRACEN((printf("NtQuerySystemTime\n")))
gettimeofday( &now, 0 );
Time->QuadPart = now.tv_sec * (ULONGLONG)TICKSPERSEC + TICKS_1601_TO_1970;
Time->QuadPart += now.tv_usec * 10;
return STATUS_SUCCESS;
}
BOOLEAN WINAPI RtlTimeToSecondsSince1970( const LARGE_INTEGER *Time, DWORD *Seconds ) {
ULONGLONG tmp = Time->QuadPart;
TRACEN((printf("RtlTimeToSecondsSince1970-1 %llx\n",tmp)))
tmp /= TICKSPERSEC;
tmp -= SECS_1601_TO_1970;
TRACEN((printf("RtlTimeToSecondsSince1970-2 %llx\n",tmp)))
if (tmp > 0xffffffff) return FALSE;
*Seconds = (DWORD)tmp;
return TRUE;
}
/*********************************************************************
* GetSystemTime (KERNEL32.@)
*
* Get the current system time.
*
* RETURNS
* Nothing.
*/
VOID WINAPI GetSystemTime(LPSYSTEMTIME systime) /* [O] Destination for current time */
{
FILETIME ft;
LARGE_INTEGER t;
TRACEN((printf("GetSystemTime\n")))
NtQuerySystemTime(&t);
ft.dwLowDateTime = (DWORD)(t.QuadPart);
ft.dwHighDateTime = (DWORD)(t.QuadPart >> 32);
FileTimeToSystemTime(&ft, systime);
}
static void WINAPI RtlLocalTimeToSystemTime( const LARGE_INTEGER *LocalTime,
LARGE_INTEGER *SystemTime) {
time_t gmt;
int bias, daylight;
TRACEN((printf("RtlLocalTimeToSystemTime\n")))
gmt = time(NULL);
bias = TIME_GetBias(gmt, &daylight);
SystemTime->QuadPart = LocalTime->QuadPart - bias * (LONGLONG)10000000;
}
BOOLEAN WINAPI RtlTimeToSecondsSince1970( const LARGE_INTEGER *Time, DWORD *Seconds ) {
ULONGLONG tmp = Time->QuadPart;
TRACEN((printf("RtlTimeToSecondsSince1970-1 %llx\n",tmp)))
tmp = RtlLargeIntegerDivide( tmp, 10000000, NULL );
tmp -= SECS_1601_TO_1970;
TRACEN((printf("RtlTimeToSecondsSince1970-2 %llx\n",tmp)))
if (tmp > 0xffffffff)
return FALSE;
*Seconds = (DWORD)tmp;
return TRUE;
}
/******************************************************************************
* RtlTimeFieldsToTime [NTDLL.@]
*
* Convert a TIME_FIELDS structure into a time.
*
* PARAMS
* ftTimeFields [I] TIME_FIELDS structure to convert.
* Time [O] Destination for the converted time.
*
* RETURNS
* Success: TRUE.
* Failure: FALSE.
*/
BOOLEAN WINAPI RtlTimeFieldsToTime(
PTIME_FIELDS tfTimeFields,
LARGE_INTEGER *Time) {
int CurYear, CurMonth, DeltaYear;
LONGLONG rcTime;
TIME_FIELDS TimeFields = *tfTimeFields;
TRACEN((printf("RtlTimeFieldsToTime\n")))
rcTime = 0;
/* FIXME: normalize the TIME_FIELDS structure here */
while (TimeFields.Second >= SECSPERMIN) {
NormalizeTimeFields(&TimeFields.Second, &TimeFields.Minute, SECSPERMIN);
}
while (TimeFields.Minute >= MINSPERHOUR) {
NormalizeTimeFields(&TimeFields.Minute, &TimeFields.Hour, MINSPERHOUR);
}
while (TimeFields.Hour >= HOURSPERDAY) {
NormalizeTimeFields(&TimeFields.Hour, &TimeFields.Day, HOURSPERDAY);
}
while (TimeFields.Day > MonthLengths[IsLeapYear(TimeFields.Year)][TimeFields.Month - 1]) {
NormalizeTimeFields(&TimeFields.Day, &TimeFields.Month, SECSPERMIN);
}
while (TimeFields.Month > MONSPERYEAR) {
NormalizeTimeFields(&TimeFields.Month, &TimeFields.Year, MONSPERYEAR);
}
/* FIXME: handle calendar corrections here */
CurYear = TimeFields.Year - EPOCHYEAR;
DeltaYear = CurYear / 400;
CurYear -= DeltaYear * 400;
rcTime += DeltaYear * DAYSPERQUADRICENTENNIUM;
DeltaYear = CurYear / 100;
CurYear -= DeltaYear * 100;
rcTime += DeltaYear * DAYSPERNORMALCENTURY;
DeltaYear = CurYear / 4;
CurYear -= DeltaYear * 4;
rcTime += DeltaYear * DAYSPERNORMALQUADRENNIUM;
rcTime += CurYear * DAYSPERNORMALYEAR;
for (CurMonth = 1; CurMonth < TimeFields.Month; CurMonth++) {
rcTime += MonthLengths[IsLeapYear(CurYear)][CurMonth - 1];
}
rcTime += TimeFields.Day - 1;
rcTime *= SECSPERDAY;
rcTime += TimeFields.Hour * SECSPERHOUR + TimeFields.Minute * SECSPERMIN + TimeFields.Second;
rcTime *= TICKSPERSEC;
rcTime += TimeFields.Milliseconds * TICKSPERMSEC;
Time->QuadPart = rcTime;
return TRUE;
}
BOOL WINAPI LocalFileTimeToFileTime( const FILETIME *localft, LPFILETIME utcft ) {
LARGE_INTEGER local, utc;
TRACEN((printf("LocalFileTimeToFileTime\n")))
local.QuadPart = localft->dwHighDateTime;
local.QuadPart = (local.QuadPart << 32) | localft->dwLowDateTime;
RtlLocalTimeToSystemTime( &local, &utc );
utcft->dwLowDateTime = (DWORD)utc.QuadPart;
utcft->dwHighDateTime = (DWORD)(utc.QuadPart >> 32);
return TRUE;
}
BOOL WINAPI FileTimeToLocalFileTime( const FILETIME *utcft, LPFILETIME localft ) {
LARGE_INTEGER local, utc;
TRACEN((printf("FileTimeToLocalFileTime\n")))
utc.QuadPart = utcft->dwHighDateTime;
utc.QuadPart = (utc.QuadPart << 32) | utcft->dwLowDateTime;
RtlSystemTimeToLocalTime( &utc, &local );
localft->dwLowDateTime = (DWORD)local.QuadPart;
localft->dwHighDateTime = (DWORD)(local.QuadPart >> 32);
return TRUE;
}
BOOL WINAPI FileTimeToDosDateTime( const FILETIME *ft, WORD *fatdate, WORD *fattime ) {
LARGE_INTEGER li;
ULONG t;
time_t unixtime;
struct tm* tm;
TRACEN((printf("FileTimeToDosDateTime\n")))
li.QuadPart = ft->dwHighDateTime;
li.QuadPart = (li.QuadPart << 32) | ft->dwLowDateTime;
RtlTimeToSecondsSince1970( &li, &t );
unixtime = t;
tm = gmtime( &unixtime );
if (fattime)
*fattime = (tm->tm_hour << 11) + (tm->tm_min << 5) + (tm->tm_sec / 2);
if (fatdate)
*fatdate = ((tm->tm_year - 80) << 9) + ((tm->tm_mon + 1) << 5) + tm->tm_mday;
return TRUE;
}
BOOL WINAPI FileTimeToSystemTime( const FILETIME *ft, LPSYSTEMTIME syst ) {
TIME_FIELDS tf;
LARGE_INTEGER t;
TRACEN((printf("FileTimeToSystemTime\n")))
t.QuadPart = ft->dwHighDateTime;
t.QuadPart = (t.QuadPart << 32) | ft->dwLowDateTime;
RtlTimeToTimeFields(&t, &tf);
syst->wYear = tf.Year;
syst->wMonth = tf.Month;
syst->wDay = tf.Day;
syst->wHour = tf.Hour;
syst->wMinute = tf.Minute;
syst->wSecond = tf.Second;
syst->wMilliseconds = tf.Milliseconds;
syst->wDayOfWeek = tf.Weekday;
return TRUE;
}
/*********************************************************************
* SystemTimeToFileTime (KERNEL32.@)
*/
BOOL WINAPI SystemTimeToFileTime( const SYSTEMTIME *syst, LPFILETIME ft ) {
TIME_FIELDS tf;
LARGE_INTEGER t;
TRACEN((printf("SystemTimeToFileTime\n")))
tf.Year = syst->wYear;
tf.Month = syst->wMonth;
tf.Day = syst->wDay;
tf.Hour = syst->wHour;
tf.Minute = syst->wMinute;
tf.Second = syst->wSecond;
tf.Milliseconds = syst->wMilliseconds;
RtlTimeFieldsToTime(&tf, &t);
ft->dwLowDateTime = (DWORD)t.QuadPart;
ft->dwHighDateTime = (DWORD)(t.QuadPart>>32);
return TRUE;
}
BOOL WINAPI DosDateTimeToFileTime( WORD fatdate, WORD fattime, FILETIME * ft) {
struct tm newtm;
TRACEN((printf("DosDateTimeToFileTime\n")))
// memset(&newtm,0,sizeof(newtm));
newtm.tm_sec = (fattime & 0x1f) * 2;
newtm.tm_min = (fattime >> 5) & 0x3f;
newtm.tm_hour = (fattime >> 11);
newtm.tm_mday = (fatdate & 0x1f);
newtm.tm_mon = ((fatdate >> 5) & 0x0f) - 1;
newtm.tm_year = (fatdate >> 9) + 80;
newtm.tm_isdst = -1;
time_t time1 = mktime(&newtm);
LONG bias = TIME_GetBias();
RtlSecondsSince1970ToFileTime( time1 - bias, ft );
TRACEN((printf("DosDateTimeToFileTime(%ld,%ld) t1=%ld bias=%ld => %lx %lx\n",
(long)fatdate,(long)fattime,(long)time1,(long)bias,
(long)ft->dwHighDateTime,(long)ft->dwLowDateTime)))
return TRUE;
}
bool CLibrary::Load(LPCTSTR lpLibFileName)
{
if(!Free())
return false;
void *handler = 0;
char name[MAX_PATHNAME_LEN+1];
#ifdef _UNICODE
AString name2 = UnicodeStringToMultiByte(lpLibFileName);
strcpy(name,nameWindowToUnix((const char *)name2));
#else
strcpy(name,nameWindowToUnix(lpLibFileName));
#endif
// replace ".dll" with ".so"
size_t len = strlen(name);
if ((len >=4) && (strcmp(name+len-4,".dll") == 0)) {
strcpy(name+len-4,".so");
}
#ifdef __ANDROID__
char tmp[MAX_PATHNAME_LEN+1];
if (strncmp(name, "./", 2) == 0) {
strcpy(tmp, name+2);
sprintf(name, "lib%s", tmp);
}
#endif
TRACEN((printf("CLibrary::Load(this=%p,%ls) => %s\n",(void *)this,lpLibFileName,name)))
#ifdef __APPLE_CC__
NSObjectFileImage image;
NSObjectFileImageReturnCode nsret;
nsret = NSCreateObjectFileImageFromFile (name, &image);
if (nsret == NSObjectFileImageSuccess) {
TRACEN((printf("NSCreateObjectFileImageFromFile(%s) : OK\n",name)))
handler = (HMODULE)NSLinkModule(image,name,NSLINKMODULE_OPTION_RETURN_ON_ERROR
| NSLINKMODULE_OPTION_PRIVATE | NSLINKMODULE_OPTION_BINDNOW);
} else {
TRACEN((printf("NSCreateObjectFileImageFromFile(%s) : ERROR\n",name)))
}
#elif ENV_BEOS
// normalize path (remove things like "./", "..", etc..), otherwise it won't work
BPath p(name, NULL, true);
status_t err = B_OK;
image_id image = load_add_on(p.Path());
TRACEN((printf("load_add_on(%s)=%d\n",p.Path(),(int)image)))
if (image < 0) {
err = (image_id)handler;
handler = 0;
} else {
err = 0;
handler = (HMODULE)image;
}
#else
int options_dlopen = 0;
#ifdef RTLD_LOCAL
options_dlopen |= RTLD_LOCAL;
#endif
#ifdef RTLD_NOW
options_dlopen |= RTLD_NOW;
#endif
#ifdef RTLD_GROUP
#if ! (defined(hpux) || defined(__hpux))
options_dlopen |= RTLD_GROUP; // mainly for solaris but not for HPUX
#endif
#endif
TRACEN((printf("CLibrary::Load - dlopen(%s,0x%d)\n",name,options_dlopen)))
handler = dlopen(name,options_dlopen);
#endif // __APPLE_CC__
TRACEN((printf("CLibrary::Load(%s) => %p\n",name,handler)))
if (handler) {
// Call DllMain() like in Windows : useless now
// Propagate the value of global_use_utf16_conversion into the plugins
int *tmp = (int *)local_GetProcAddress(handler,"global_use_utf16_conversion");
if (tmp) *tmp = global_use_utf16_conversion;
#ifdef ENV_HAVE_LSTAT
tmp = (int *)local_GetProcAddress(handler,"global_use_lstat");
if (tmp) *tmp = global_use_lstat;
#endif
// test construtors calls
void (*fctTest)(void) = (void (*)(void))local_GetProcAddress(handler,"sync_TestConstructor");
if (fctTest) fctTest();
} else {
#ifdef __APPLE_CC__
NSLinkEditErrors c;
int num_err;
const char *file,*err;
NSLinkEditError(&c,&num_err,&file,&err);
printf("Can't load '%ls' (%s)\n", lpLibFileName,err);
#elif ENV_BEOS
printf("Can't load '%ls' (%s)\n", lpLibFileName,strerror(err));
#else
printf("Can't load '%ls' (%s)\n", lpLibFileName,dlerror());
#endif
}
_module = handler;
TRACEN((printf("CLibrary::Load(this=%p,%ls) => _module=%p\n",(void *)this,lpLibFileName,_module)))
return true;
}
