Removed a number of internal file functions that are no longer used.

dlls/kernel/Makefile.in

@@ -19,7 +19,6 @@ SPEC_SRCS16 = \
 
 C_SRCS = \
 	$(TOPOBJDIR)/files/directory.c \
-	$(TOPOBJDIR)/files/dos_fs.c \
 	$(TOPOBJDIR)/files/drive.c \
 	$(TOPOBJDIR)/files/file.c \
 	$(TOPOBJDIR)/files/smb.c \

dlls/kernel/kernel_main.c

@@ -244,3 +244,34 @@ BOOL WINAPI SwitchToThread(void)
     Sleep(0);
     return 1;
 }
+
+
+/***********************************************************************
+ *           MulDiv   (KERNEL32.@)
+ * RETURNS
+ *	Result of multiplication and division
+ *	-1: Overflow occurred or Divisor was 0
+ */
+INT WINAPI MulDiv( INT nMultiplicand, INT nMultiplier, INT nDivisor)
+{
+    LONGLONG ret;
+
+    if (!nDivisor) return -1;
+
+    /* We want to deal with a positive divisor to simplify the logic. */
+    if (nDivisor < 0)
+    {
+      nMultiplicand = - nMultiplicand;
+      nDivisor = -nDivisor;
+    }
+
+    /* If the result is positive, we "add" to round. else, we subtract to round. */
+    if ( ( (nMultiplicand <  0) && (nMultiplier <  0) ) ||
+         ( (nMultiplicand >= 0) && (nMultiplier >= 0) ) )
+      ret = (((LONGLONG)nMultiplicand * nMultiplier) + (nDivisor/2)) / nDivisor;
+    else
+      ret = (((LONGLONG)nMultiplicand * nMultiplier) - (nDivisor/2)) / nDivisor;
+
+    if ((ret > 2147483647) || (ret < -2147483647)) return -1;
+    return ret;
+}

dlls/kernel/time.c

@@ -891,3 +891,57 @@ BOOL WINAPI GetDaylightFlag(void)
     struct tm *ptm = localtime( &t);
     return ptm->tm_isdst > 0;
 }
+
+
+/***********************************************************************
+ *           DosDateTimeToFileTime   (KERNEL32.@)
+ */
+BOOL WINAPI DosDateTimeToFileTime( WORD fatdate, WORD fattime, LPFILETIME ft)
+{
+    struct tm newtm;
+#ifndef HAVE_TIMEGM
+    struct tm *gtm;
+    time_t time1, time2;
+#endif
+
+    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
+    RtlSecondsSince1970ToTime( timegm(&newtm), (LARGE_INTEGER *)ft );
+#else
+    time1 = mktime(&newtm);
+    gtm = gmtime(&time1);
+    time2 = mktime(gtm);
+    RtlSecondsSince1970ToTime( 2*time1-time2, (LARGE_INTEGER *)ft );
+#endif
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *           FileTimeToDosDateTime   (KERNEL32.@)
+ */
+BOOL WINAPI FileTimeToDosDateTime( const FILETIME *ft, LPWORD fatdate,
+                                     LPWORD fattime )
+{
+    LARGE_INTEGER       li;
+    ULONG               t;
+    time_t              unixtime;
+    struct tm*          tm;
+
+    li.u.LowPart = ft->dwLowDateTime;
+    li.u.HighPart = ft->dwHighDateTime;
+    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;
+}

files/directory.c

@@ -223,8 +223,6 @@ int DIR_Init(void)
     TRACE("SystemDir  = %s\n", debugstr_w(DIR_System) );
     TRACE("TempDir    = %s\n", debugstr_w(tmp_dir) );
     TRACE("SYSTEMROOT = %s\n", debugstr_w(DIR_Windows) );
-    TRACE("Cwd        = %c:\\%s\n",
-          'A' + drive, debugstr_w(DRIVE_GetDosCwd(drive)) );
 
     HeapFree( GetProcessHeap(), 0, tmp_dir );
 

files/drive.c

@@ -64,8 +64,6 @@ WINE_DECLARE_DEBUG_CHANNEL(file);
 typedef struct
 {
     char     *root;      /* root dir in Unix format without trailing / */
-    LPWSTR    dos_cwd;   /* cwd in DOS format without leading or trailing \ */
-    char     *unix_cwd;  /* cwd in Unix format without leading or trailing / */
     char     *device;    /* raw device path */
     dev_t     dev;       /* unix device number */
     ino_t     ino;       /* unix inode number */
@@ -75,9 +73,6 @@ typedef struct
 #define MAX_DOS_DRIVES  26
 
 static DOSDRIVE DOSDrives[MAX_DOS_DRIVES];
-static int DRIVE_CurDrive = -1;
-
-static HTASK16 DRIVE_LastTask = 0;
 
 /* strdup on the process heap */
 inline static char *heap_strdup( const char *str )
@@ -97,7 +92,6 @@ int DRIVE_Init(void)
     WCHAR driveW[] = {'M','a','c','h','i','n','e','\\','S','o','f','t','w','a','r','e','\\',
                       'W','i','n','e','\\','W','i','n','e','\\',
                       'C','o','n','f','i','g','\\','D','r','i','v','e',' ','A',0};
-    WCHAR drive_env[] = {'=','A',':',0};
     WCHAR path[MAX_PATHNAME_LEN];
     char tmp[MAX_PATHNAME_LEN*sizeof(WCHAR) + sizeof(KEY_VALUE_PARTIAL_INFORMATION)];
     struct stat drive_stat_buffer;
@@ -145,8 +139,6 @@ int DRIVE_Init(void)
             continue;
         }
         drive->root     = root;
-        drive->dos_cwd  = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(drive->dos_cwd[0]));
-        drive->unix_cwd = heap_strdup( "" );
         drive->device   = NULL;
         drive->dev      = drive_stat_buffer.st_dev;
         drive->ino      = drive_stat_buffer.st_ino;
@@ -210,8 +202,6 @@ int DRIVE_Init(void)
                     goto next;
                 }
 
-                drive->dos_cwd  = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(drive->dos_cwd[0]));
-                drive->unix_cwd = heap_strdup( "" );
                 drive->device   = NULL;
                 drive->dev      = drive_stat_buffer.st_dev;
                 drive->ino      = drive_stat_buffer.st_ino;
@@ -238,39 +228,6 @@ int DRIVE_Init(void)
     next:
         NtClose( hkey );
     }
-
-    if (!count && !symlink_count)
-    {
-        MESSAGE("Warning: no valid DOS drive found, check your configuration file.\n" );
-        /* Create a C drive pointing to Unix root dir */
-        DOSDrives[2].root     = heap_strdup( "/" );
-        DOSDrives[2].dos_cwd  = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DOSDrives[2].dos_cwd[0]));
-        DOSDrives[2].unix_cwd = heap_strdup( "" );
-        DOSDrives[2].device   = NULL;
-        DRIVE_CurDrive = 2;
-    }
-
-    /* Make sure the current drive is valid */
-    if (DRIVE_CurDrive == -1)
-    {
-        for (i = 2, drive = DOSDrives; i < MAX_DOS_DRIVES; i++, drive++)
-        {
-            if (drive->root)
-            {
-                DRIVE_CurDrive = i;
-                break;
-            }
-        }
-    }
-
-    /* get current working directory info for all drives */
-    for (i = 0; i < MAX_DOS_DRIVES; i++, drive_env[1]++)
-    {
-        if (!GetEnvironmentVariableW(drive_env, path, MAX_PATHNAME_LEN)) continue;
-        /* sanity check */
-        if (toupperW(path[0]) != drive_env[1] || path[1] != ':') continue;
-        DRIVE_Chdir( i, path + 2 );
-    }
     return 1;
 }
 
@@ -286,17 +243,6 @@ int DRIVE_IsValid( int drive )
 
 
 /***********************************************************************
- *           DRIVE_GetCurrentDrive
- */
-int DRIVE_GetCurrentDrive(void)
-{
-    TDB *pTask = GlobalLock16(GetCurrentTask());
-    if (pTask && (pTask->curdrive & 0x80)) return pTask->curdrive & ~0x80;
-    return DRIVE_CurDrive;
-}
-
-
-/***********************************************************************
  *           DRIVE_FindDriveRoot
  *
  * Find a drive for which the root matches the beginning of the given path.
@@ -443,112 +389,9 @@ const char * DRIVE_GetRoot( int drive )
 
 
 /***********************************************************************
- *           DRIVE_GetDosCwd
- */
-LPCWSTR DRIVE_GetDosCwd( int drive )
-{
-    TDB *pTask = GlobalLock16(GetCurrentTask());
-    if (!DRIVE_IsValid( drive )) return NULL;
-
-    /* Check if we need to change the directory to the new task. */
-    if (pTask && (pTask->curdrive & 0x80) &&    /* The task drive is valid */
-        ((pTask->curdrive & ~0x80) == drive) && /* and it's the one we want */
-        (DRIVE_LastTask != GetCurrentTask()))   /* and the task changed */
-    {
-        static const WCHAR rootW[] = {'\\',0};
-        WCHAR curdirW[MAX_PATH];
-        MultiByteToWideChar(CP_ACP, 0, pTask->curdir, -1, curdirW, MAX_PATH);
-        /* Perform the task-switch */
-        if (!DRIVE_Chdir( drive, curdirW )) DRIVE_Chdir( drive, rootW );
-        DRIVE_LastTask = GetCurrentTask();
-    }
-    return DOSDrives[drive].dos_cwd;
-}
-
-
-/***********************************************************************
- *           DRIVE_GetUnixCwd
- */
-const char * DRIVE_GetUnixCwd( int drive )
-{
-    TDB *pTask = GlobalLock16(GetCurrentTask());
-    if (!DRIVE_IsValid( drive )) return NULL;
-
-    /* Check if we need to change the directory to the new task. */
-    if (pTask && (pTask->curdrive & 0x80) &&    /* The task drive is valid */
-        ((pTask->curdrive & ~0x80) == drive) && /* and it's the one we want */
-        (DRIVE_LastTask != GetCurrentTask()))   /* and the task changed */
-    {
-        static const WCHAR rootW[] = {'\\',0};
-        WCHAR curdirW[MAX_PATH];
-        MultiByteToWideChar(CP_ACP, 0, pTask->curdir, -1, curdirW, MAX_PATH);
-        /* Perform the task-switch */
-        if (!DRIVE_Chdir( drive, curdirW )) DRIVE_Chdir( drive, rootW );
-        DRIVE_LastTask = GetCurrentTask();
-    }
-    return DOSDrives[drive].unix_cwd;
-}
-
-
-/***********************************************************************
  *           DRIVE_GetDevice
  */
 const char * DRIVE_GetDevice( int drive )
 {
     return (DRIVE_IsValid( drive )) ? DOSDrives[drive].device : NULL;
 }
-
-/***********************************************************************
- *           DRIVE_Chdir
- */
-int DRIVE_Chdir( int drive, LPCWSTR path )
-{
-    DOS_FULL_NAME full_name;
-    WCHAR buffer[MAX_PATHNAME_LEN];
-    LPSTR unix_cwd;
-    BY_HANDLE_FILE_INFORMATION info;
-    TDB *pTask = GlobalLock16(GetCurrentTask());
-
-    buffer[0] = 'A' + drive;
-    buffer[1] = ':';
-    buffer[2] = 0;
-    TRACE("(%s,%s)\n", debugstr_w(buffer), debugstr_w(path) );
-    strncpyW( buffer + 2, path, MAX_PATHNAME_LEN - 2 );
-    buffer[MAX_PATHNAME_LEN - 1] = 0; /* ensure 0 termination */
-
-    if (!DOSFS_GetFullName( buffer, TRUE, &full_name )) return 0;
-    if (!FILE_Stat( full_name.long_name, &info, NULL )) return 0;
-    if (!(info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
-    {
-        SetLastError( ERROR_FILE_NOT_FOUND );
-        return 0;
-    }
-    unix_cwd = full_name.long_name + strlen( DOSDrives[drive].root );
-    while (*unix_cwd == '/') unix_cwd++;
-
-    TRACE("(%c:): unix_cwd=%s dos_cwd=%s\n",
-            'A' + drive, unix_cwd, debugstr_w(full_name.short_name + 3) );
-
-    HeapFree( GetProcessHeap(), 0, DOSDrives[drive].dos_cwd );
-    HeapFree( GetProcessHeap(), 0, DOSDrives[drive].unix_cwd );
-    DOSDrives[drive].dos_cwd  = HeapAlloc(GetProcessHeap(), 0, (strlenW(full_name.short_name) - 2) * sizeof(WCHAR));
-    strcpyW(DOSDrives[drive].dos_cwd, full_name.short_name + 3);
-    DOSDrives[drive].unix_cwd = heap_strdup( unix_cwd );
-
-    if (drive == DRIVE_CurDrive)
-    {
-        UNICODE_STRING dirW;
-
-        RtlInitUnicodeString( &dirW, full_name.short_name );
-        RtlSetCurrentDirectory_U( &dirW );
-    }
-
-    if (pTask && (pTask->curdrive & 0x80) &&
-        ((pTask->curdrive & ~0x80) == drive))
-    {
-        WideCharToMultiByte(CP_ACP, 0, full_name.short_name + 2, -1,
-                            pTask->curdir, sizeof(pTask->curdir), NULL, NULL);
-        DRIVE_LastTask = GetCurrentTask();
-    }
-    return 1;
-}

files/file.c

@@ -80,14 +80,6 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(file);
 
-#if defined(MAP_ANONYMOUS) && !defined(MAP_ANON)
-#define MAP_ANON MAP_ANONYMOUS
-#endif
-
-#define IS_OPTION_TRUE(ch) ((ch) == 'y' || (ch) == 'Y' || (ch) == 't' || (ch) == 'T' || (ch) == '1')
-
-#define SECSPERDAY         86400
-#define SECS_1601_TO_1970  ((369 * 365 + 89) * (ULONGLONG)SECSPERDAY)
 
 /***********************************************************************
  *              FILE_ConvertOFMode
@@ -552,93 +544,6 @@ static void FILE_FillInfo( struct stat *st, BY_HANDLE_FILE_INFORMATION *info )
 
 
 /***********************************************************************
- *           get_show_dot_files_option
- */
-static BOOL get_show_dot_files_option(void)
-{
-    static const WCHAR WineW[] = {'M','a','c','h','i','n','e','\\',
-                                  'S','o','f','t','w','a','r','e','\\',
-                                  'W','i','n','e','\\','W','i','n','e','\\',
-                                  'C','o','n','f','i','g','\\','W','i','n','e',0};
-    static const WCHAR ShowDotFilesW[] = {'S','h','o','w','D','o','t','F','i','l','e','s',0};
-
-    char tmp[80];
-    HKEY hkey;
-    DWORD dummy;
-    OBJECT_ATTRIBUTES attr;
-    UNICODE_STRING nameW;
-    BOOL ret = FALSE;
-
-    attr.Length = sizeof(attr);
-    attr.RootDirectory = 0;
-    attr.ObjectName = &nameW;
-    attr.Attributes = 0;
-    attr.SecurityDescriptor = NULL;
-    attr.SecurityQualityOfService = NULL;
-    RtlInitUnicodeString( &nameW, WineW );
-
-    if (!NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr ))
-    {
-        RtlInitUnicodeString( &nameW, ShowDotFilesW );
-        if (!NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation, tmp, sizeof(tmp), &dummy ))
-        {
-            WCHAR *str = (WCHAR *)((KEY_VALUE_PARTIAL_INFORMATION *)tmp)->Data;
-            ret = IS_OPTION_TRUE( str[0] );
-        }
-        NtClose( hkey );
-    }
-    return ret;
-}
-
-
-/***********************************************************************
- *           FILE_Stat
- *
- * Stat a Unix path name. Return TRUE if OK.
- */
-BOOL FILE_Stat( LPCSTR unixName, BY_HANDLE_FILE_INFORMATION *info, BOOL *is_symlink_ptr )
-{
-    struct stat st;
-    int is_symlink;
-    LPCSTR p;
-
-    if (lstat( unixName, &st ) == -1)
-    {
-        FILE_SetDosError();
-        return FALSE;
-    }
-    is_symlink = S_ISLNK(st.st_mode);
-    if (is_symlink)
-    {
-        /* do a "real" stat to find out
-	   about the type of the symlink destination */
-        if (stat( unixName, &st ) == -1)
-        {
-            FILE_SetDosError();
-            return FALSE;
-        }
-    }
-
-    /* fill in the information we gathered so far */
-    FILE_FillInfo( &st, info );
-
-    /* and now see if this is a hidden file, based on the name */
-    p = strrchr( unixName, '/');
-    p = p ? p + 1 : unixName;
-    if (*p == '.' && *(p+1)  && (*(p+1) != '.' || *(p+2)))
-    {
-	static int show_dot_files = -1;
-	if (show_dot_files == -1)
-	    show_dot_files = get_show_dot_files_option();
-	if (!show_dot_files)
-	    info->dwFileAttributes |= FILE_ATTRIBUTE_HIDDEN;
-    }
-    if (is_symlink_ptr) *is_symlink_ptr = is_symlink;
-    return TRUE;
-}
-
-
-/***********************************************************************
  *             GetFileInformationByHandle   (KERNEL32.@)
  */
 BOOL WINAPI GetFileInformationByHandle( HANDLE hFile, BY_HANDLE_FILE_INFORMATION *info )

include/file.h

@@ -27,38 +27,18 @@
 
 #define MAX_PATHNAME_LEN   1024
 
-/* Definition of a full DOS file name */
-typedef struct
-{
-    char  long_name[MAX_PATHNAME_LEN];  /* Long pathname in Unix format */
-    WCHAR short_name[MAX_PATHNAME_LEN]; /* Short pathname in DOS 8.3 format */
-    int   drive;
-} DOS_FULL_NAME;
-
 /* files/file.c */
 extern void FILE_SetDosError(void);
-extern BOOL FILE_Stat( LPCSTR unixName, BY_HANDLE_FILE_INFORMATION *info, BOOL *is_symlink );
-extern HANDLE FILE_CreateFile( LPCSTR filename, DWORD access, DWORD sharing,
-                               LPSECURITY_ATTRIBUTES sa, DWORD creation,
-                               DWORD attributes, HANDLE template );
 
 /* files/directory.c */
 extern int DIR_Init(void);
 
-/* files/dos_fs.c */
-extern BOOL DOSFS_GetFullName( LPCWSTR name, BOOL check_last, DOS_FULL_NAME *full );
-
 /* drive.c */
 extern int DRIVE_Init(void);
-extern int DRIVE_IsValid( int drive );
-extern int DRIVE_GetCurrentDrive(void);
 extern int DRIVE_FindDriveRoot( const char **path );
 extern int DRIVE_FindDriveRootW( LPCWSTR *path );
 extern const char * DRIVE_GetRoot( int drive );
-extern LPCWSTR DRIVE_GetDosCwd( int drive );
-extern const char * DRIVE_GetUnixCwd( int drive );
 extern const char * DRIVE_GetDevice( int drive );
-extern int DRIVE_Chdir( int drive, LPCWSTR path );
 
 /* vxd.c */
 extern HANDLE VXD_Open( LPCWSTR filename, DWORD access, LPSECURITY_ATTRIBUTES sa );