diff --git a/files/Makefile.in b/files/Makefile.in
index 5fee060..cf17c1c 100644
--- a/files/Makefile.in
+++ b/files/Makefile.in
@@ -5,7 +5,8 @@
 	directory.c \
 	dos_fs.c \
 	drive.c \
-	file.c
+	file.c \
+	profile.c
 
 all: $(MODULE).o
 
diff --git a/files/directory.c b/files/directory.c
index 9de0c52..5365bd6 100644
--- a/files/directory.c
+++ b/files/directory.c
@@ -13,6 +13,7 @@
 #include "drive.h"
 #include "file.h"
 #include "msdos.h"
+#include "options.h"
 #include "xmalloc.h"
 #include "stddebug.h"
 #include "debug.h"
@@ -42,8 +43,7 @@
     const char *dos_name ,*unix_name;
     BYTE attr;
 
-    GetPrivateProfileString( "wine", keyname, defval,
-                             path, sizeof(path), WineIniFileName() );
+    PROFILE_GetWineIniString( "wine", keyname, defval, path, sizeof(path) );
     if (!(unix_name = DOSFS_GetUnixFileName( path, TRUE )) ||
         !FILE_Stat( unix_name, &attr, NULL, NULL, NULL ) ||
         !(attr & FA_DIRECTORY))
@@ -117,7 +117,7 @@
  */
 int DIR_Init(void)
 {
-    char path[MAX_PATHNAME_LEN];
+    char path[MAX_PATHNAME_LEN], *env_p;
     int drive;
     const char *cwd;
 
@@ -153,14 +153,26 @@
         DRIVE_Chdir( drive, DIR_WindowsDosDir + 2 );
     }
 
-    GetPrivateProfileString( "wine", "path", "c:\\windows;c:\\windows\\system",
-                             path, sizeof(path), WineIniFileName() );
+    PROFILE_GetWineIniString("wine", "path", "c:\\windows;c:\\windows\\system",
+                             path, sizeof(path) );
     DIR_ParseWindowsPath( path );
 
     dprintf_dosfs( stddeb, "WindowsDir = %s\nSystemDir  = %s\n",
                    DIR_WindowsDosDir, DIR_SystemDosDir );
     dprintf_dosfs( stddeb, "TempDir    = %s\nCwd        = %c:\\%s\n",
                    DIR_TempDosDir, 'A' + drive, DRIVE_GetDosCwd( drive ) );
+
+    /* Put the temp and Windows directories into the environment */
+
+    env_p = (char *)xmalloc( strlen(DIR_TempDosDir) + 5 );
+    strcpy( env_p, "TEMP=" );
+    strcpy( env_p + 5, DIR_TempDosDir );
+    putenv( env_p );
+    env_p = (char *)xmalloc( strlen(DIR_WindowsDosDir) + 7 );
+    strcpy( env_p, "windir=" );
+    strcpy( env_p + 7, DIR_WindowsDosDir );
+    putenv( env_p );
+
     return 1;
 }
 
diff --git a/files/dos_fs.c b/files/dos_fs.c
index 6f4e921..29131ec 100644
--- a/files/dos_fs.c
+++ b/files/dos_fs.c
@@ -25,7 +25,7 @@
 #include "debug.h"
 
 /* Chars we don't want to see in DOS file names */
-#define INVALID_DOS_CHARS  "*?<>|\"+=,; "
+#define INVALID_DOS_CHARS  "*?<>|\"+=,;[] \345"
 
 static const char *DOSFS_Devices[][2] =
 {
@@ -264,7 +264,8 @@
     if (pTime)
         *pTime = (tm->tm_hour << 11) + (tm->tm_min << 5) + (tm->tm_sec / 2);
     if (pDate)
-        *pDate = ((tm->tm_year - 80) << 9) + (tm->tm_mon << 5) + tm->tm_mday;
+        *pDate = ((tm->tm_year - 80) << 9) + ((tm->tm_mon + 1) << 5)
+                 + tm->tm_mday;
 }
 
 
@@ -506,7 +507,7 @@
             p += strlen(p);
             while (!IS_END_OF_NAME(*name)) name++;
         }
-        else
+        else if (!check_last)
         {
             *p++ = '/';
             for (len--; !IS_END_OF_NAME(*name) && (len > 1); name++, len--)
@@ -517,16 +518,16 @@
     }
     if (!found)
     {
-        if (*name)  /* Not last */
-        {
-            DOS_ERROR( ER_PathNotFound, EC_NotFound, SA_Abort, EL_Disk );
-            return NULL;
-        }
         if (check_last)
         {
             DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk );
             return NULL;
         }
+        if (*name)  /* Not last */
+        {
+            DOS_ERROR( ER_PathNotFound, EC_NotFound, SA_Abort, EL_Disk );
+            return NULL;
+        }
     }
     if (!buffer[0]) strcpy( buffer, "/" );
     dprintf_dosfs( stddeb, "DOSFS_GetUnixFileName: returning %s\n", buffer );
@@ -571,19 +572,20 @@
         return NULL;
     }
 
-    strcpy( buffer, "A:\\" );
-    buffer[0] += drive;
-    if ((name[0] == '\\') || (name[0] == '/'))
+    p = buffer;
+    *p++ = 'A' + drive;
+    *p++ = ':';
+    if (IS_END_OF_NAME(*name))
     {
         while ((*name == '\\') || (*name == '/')) name++;
-        p = buffer + 2;
     }
     else
     {
-        lstrcpyn( buffer + 3, DRIVE_GetDosCwd(drive), len - 3 );
-        if (buffer[3]) p = buffer + strlen(buffer);
-        else p = buffer + 2;
+        *p++ = '\\';
+        lstrcpyn( p, DRIVE_GetDosCwd(drive), sizeof(buffer) - 3 );
+        if (*p) p += strlen(p); else p--;
     }
+    *p = '\0';
     len = MAX_PATHNAME_LEN - (int)(p - buffer);
 
     while (*name)
@@ -616,10 +618,10 @@
                 name++;
                 len--;
             }
+            *p = '\0';
         }
         while ((*name == '\\') || (*name == '/')) name++;
     }
-    *p = '\0';
     if (!buffer[2])
     {
         buffer[2] = '\\';
@@ -639,10 +641,12 @@
 int DOSFS_FindNext( const char *path, const char *mask, int drive,
                     BYTE attr, int skip, DOS_DIRENT *entry )
 {
-    DIR *dir;
+    static DIR *dir = NULL;
     struct dirent *dirent;
     int count = 0;
-    char buffer[MAX_PATHNAME_LEN], *p;
+    static char buffer[MAX_PATHNAME_LEN];
+    static int cur_pos = 0;
+    char *p;
     const char *hash_name;
     
     if ((attr & ~(FA_UNUSED | FA_ARCHIVE | FA_RDONLY)) == FA_LABEL)
@@ -656,8 +660,17 @@
         return 1;
     }
 
-    if (!(dir = opendir( path ))) return 0;
-    strcpy( buffer, path );
+    /* Check the cached directory */
+    if (dir && !strcmp( buffer, path ) && (cur_pos <= skip)) skip -= cur_pos;
+    else  /* Not in the cache, open it anew */
+    {
+        dprintf_dosfs( stddeb, "DOSFS_FindNext: cache miss, path=%s skip=%d buf=%s cur=%d\n",
+                       path, skip, buffer, cur_pos );
+        cur_pos = skip;
+        if (dir) closedir(dir);
+        if (!(dir = opendir( path ))) return 0;
+        lstrcpyn( buffer, path, sizeof(buffer) - 1 );
+    }
     strcat( buffer, "/" );
     p = buffer + strlen(buffer);
     attr |= FA_UNUSED | FA_ARCHIVE | FA_RDONLY;
@@ -668,7 +681,7 @@
         count++;
         hash_name = DOSFS_Hash( dirent->d_name, TRUE );
         if (!DOSFS_Match( mask, hash_name )) continue;
-        strcpy( p, dirent->d_name );
+        lstrcpyn( p, dirent->d_name, sizeof(buffer) - (int)(p - buffer) );
 
         if (!FILE_Stat( buffer, &entry->attr, &entry->size,
                         &entry->date, &entry->time ))
@@ -681,9 +694,11 @@
         lstrcpyn( entry->unixname, dirent->d_name, sizeof(entry->unixname) );
         dprintf_dosfs( stddeb, "DOSFS_FindNext: returning %s %02x %ld\n",
                        entry->name, entry->attr, entry->size );
-        closedir( dir );
+        cur_pos += count;
+        p[-1] = '\0';  /* Remove trailing slash in buffer */
         return count;
     }
     closedir( dir );
+    dir = NULL;
     return 0;  /* End of directory */
 }
diff --git a/files/drive.c b/files/drive.c
index ae2558d..5c72a54 100644
--- a/files/drive.c
+++ b/files/drive.c
@@ -1,5 +1,5 @@
 /*
- * DOS drive handling functions
+ * DOS drives handling functions
  *
  * Copyright 1993 Erik Bos
  * Copyright 1996 Alexandre Julliard
@@ -7,12 +7,26 @@
 
 #include <string.h>
 #include <stdlib.h>
+#include <sys/stat.h>
+
+#if defined(__linux__) || defined(sun)
+#include <sys/vfs.h>
+#endif
+#if defined(__NetBSD__) || defined(__FreeBSD__)
+#include <sys/param.h>
+#include <sys/mount.h>
+#include <sys/errno.h>
+#endif
+#ifdef __svr4__
+#include <sys/statfs.h>
+#endif
 
 #include "windows.h"
 #include "dos_fs.h"
 #include "drive.h"
 #include "file.h"
 #include "msdos.h"
+#include "options.h"
 #include "task.h"
 #include "xmalloc.h"
 #include "stddebug.h"
@@ -20,74 +34,128 @@
 
 typedef struct
 {
-    char *root;      /* root dir in Unix format without trailing '/' */
-    char *dos_cwd;   /* cwd in DOS format without leading or trailing '\' */
-    char *unix_cwd;  /* cwd in Unix format without leading or trailing '/' */
-    char  label[12]; /* drive label */
-    DWORD serial;    /* drive serial number */
-    WORD  type;      /* drive type */
-    BYTE  disabled;  /* disabled flag */
+    char     *root;      /* root dir in Unix format without trailing / */
+    char     *dos_cwd;   /* cwd in DOS format without leading or trailing \ */
+    char     *unix_cwd;  /* cwd in Unix format without leading or trailing / */
+    char      label[12]; /* drive label */
+    DWORD     serial;    /* drive serial number */
+    DRIVETYPE type;      /* drive type */
+    BYTE  disabled;      /* disabled flag */
 } DOSDRIVE;
 
+
+static const char *DRIVE_Types[] =
+{
+    "floppy",   /* TYPE_FLOPPY */
+    "hd",       /* TYPE_HD */
+    "cdrom",    /* TYPE_CDROM */
+    "network"   /* TYPE_NETWORK */
+};
+
+
 static DOSDRIVE DOSDrives[MAX_DOS_DRIVES];
-static int DRIVE_CurDrive = 0;
+static int DRIVE_CurDrive = -1;
 
 static HTASK DRIVE_LastTask = 0;
 
+
+/***********************************************************************
+ *           DRIVE_GetDriveType
+ */
+static DRIVETYPE DRIVE_GetDriveType( const char *name )
+{
+    char buffer[20];
+    int i;
+
+    PROFILE_GetWineIniString( name, "Type", "hd", buffer, sizeof(buffer) );
+    for (i = 0; i < sizeof(DRIVE_Types)/sizeof(DRIVE_Types[0]); i++)
+    {
+        if (!lstrcmpi( buffer, DRIVE_Types[i] )) return (DRIVETYPE)i;
+    }
+    fprintf( stderr, "%s: unknown type '%s', defaulting to 'hd'.\n",
+             name, buffer );
+    return TYPE_HD;
+}
+
+
 /***********************************************************************
  *           DRIVE_Init
  */
 int DRIVE_Init(void)
 {
-    int i, count = 0;
-    char drive[2] = "A";
+    int i, len, count = 0;
+    char name[] = "Drive A";
     char path[MAX_PATHNAME_LEN];
+    char buffer[20];
     char *p;
+    DOSDRIVE *drive;
 
-    for (i = 0; i < MAX_DOS_DRIVES; i++, drive[0]++)
+    for (i = 0, drive = DOSDrives; i < MAX_DOS_DRIVES; i++, name[6]++, drive++)
     {
-        GetPrivateProfileString( "drives", drive, "",
-                                 path, sizeof(path)-1, WineIniFileName() );
+        PROFILE_GetWineIniString( name, "Path", "", path, sizeof(path)-1 );
         if (path[0])
         {
             p = path + strlen(path) - 1;
             while ((p > path) && ((*p == '/') || (*p == '\\'))) *p-- = '\0';
-            DOSDrives[i].root     = xstrdup( path );
-            DOSDrives[i].dos_cwd  = xstrdup( "" );
-            DOSDrives[i].unix_cwd = xstrdup( "" );
-            sprintf( DOSDrives[i].label, "DRIVE-%c    ", drive[0] );
-            DOSDrives[i].serial   = 0x12345678;
-            DOSDrives[i].type     = (i < 2) ? DRIVE_REMOVABLE : DRIVE_FIXED;
-            DOSDrives[i].disabled = 0;
+            drive->root     = xstrdup( path );
+            drive->dos_cwd  = xstrdup( "" );
+            drive->unix_cwd = xstrdup( "" );
+            drive->type     = DRIVE_GetDriveType( name );
+            drive->disabled = 0;
+
+            /* Get the drive label */
+            PROFILE_GetWineIniString( name, "Label", name, drive->label, 12 );
+            if ((len = strlen(drive->label)) < 11)
+            {
+                /* Pad label with spaces */
+                memset( drive->label + len, ' ', 11 - len );
+                drive->label[12] = '\0';
+            }
+
+            /* Get the serial number */
+            PROFILE_GetWineIniString( name, "Serial", "12345678",
+                                      buffer, sizeof(buffer) );
+            drive->serial = strtoul( buffer, NULL, 16 );
+
+            /* Make the first hard disk the current drive */
+            if ((DRIVE_CurDrive == -1) && (drive->type == TYPE_HD))
+                DRIVE_CurDrive = i;
+
             count++;
+            dprintf_dosfs( stddeb, "%s: path=%s type=%s label='%s' serial=%08lx\n",
+                           name, path, DRIVE_Types[drive->type],
+                           drive->label, drive->serial );
         }
-        dprintf_dosfs( stddeb, "Drive %c -> %s\n", 'A' + i,
-                       path[0] ? path : "** None **" );
+        else dprintf_dosfs( stddeb, "%s: not defined\n", name );
     }
 
     if (!count) 
     {
         fprintf( stderr, "Warning: no valid DOS drive found\n" );
         /* Create a C drive pointing to Unix root dir */
-        DOSDrives[i].root     = xstrdup( "/" );
-        DOSDrives[i].dos_cwd  = xstrdup( "" );
-        DOSDrives[i].unix_cwd = xstrdup( "" );
-        sprintf( DOSDrives[i].label, "DRIVE-%c    ", drive[0] );
-        DOSDrives[i].serial   = 0x12345678;
-        DOSDrives[i].type     = DRIVE_FIXED;
-        DOSDrives[i].disabled = 0;
+        DOSDrives[2].root     = xstrdup( "/" );
+        DOSDrives[2].dos_cwd  = xstrdup( "" );
+        DOSDrives[2].unix_cwd = xstrdup( "" );
+        strcpy( DOSDrives[2].label, "Drive C    " );
+        DOSDrives[2].serial   = 0x12345678;
+        DOSDrives[2].type     = TYPE_HD;
+        DOSDrives[2].disabled = 0;
+        DRIVE_CurDrive = 2;
     }
 
-    /* Make the first hard disk the current drive */
-    for (i = 0; i < MAX_DOS_DRIVES; i++, drive[0]++)
+    /* Make sure the current drive is valid */
+    if (DRIVE_CurDrive == -1)
     {
-        if (DOSDrives[i].root && !DOSDrives[i].disabled &&
-            DOSDrives[i].type != DRIVE_REMOVABLE)
+        for (i = 0, drive = DOSDrives; i < MAX_DOS_DRIVES; i++, drive++)
         {
-            DRIVE_CurDrive = i;
-            break;
+            if (drive->root && !drive->disabled)
+            {
+                DRIVE_CurDrive = i;
+                break;
+            }
         }
     }
+
     return 1;
 }
 
@@ -143,7 +211,7 @@
  */
 int DRIVE_FindDriveRoot( const char **path )
 {
-    int drive;
+    int drive, rootdrive = -1;
     const char *p1, *p2;
 
     dprintf_dosfs( stddeb, "DRIVE_FindDriveRoot: searching '%s'\n", *path );
@@ -154,6 +222,13 @@
         p2 = DOSDrives[drive].root;
         dprintf_dosfs( stddeb, "DRIVE_FindDriveRoot: checking %c: '%s'\n",
                        'A' + drive, p2 );
+        
+        while (*p2 == '/') p2++;
+        if (!*p2)
+        {
+            rootdrive = drive;
+            continue;  /* Look if there's a better match */
+        }
         for (;;)
         {
             while ((*p1 == '\\') || (*p1 == '/')) p1++;
@@ -175,7 +250,7 @@
             break;  /* No match, go to next drive */
         }
     }
-    return -1;
+    return rootdrive;
 }
 
 
@@ -263,6 +338,16 @@
 
 
 /***********************************************************************
+ *           DRIVE_GetType
+ */
+DRIVETYPE DRIVE_GetType( int drive )
+{
+    if (!DRIVE_IsValid( drive )) return TYPE_INVALID;
+    return DOSDrives[drive].type;
+}
+
+
+/***********************************************************************
  *           DRIVE_Chdir
  */
 int DRIVE_Chdir( int drive, const char *path )
@@ -339,11 +424,52 @@
 
 
 /***********************************************************************
+ *           DRIVE_GetFreeSpace
+ */
+int DRIVE_GetFreeSpace( int drive, DWORD *size, DWORD *available )
+{
+    struct statfs info;
+
+    if (!DRIVE_IsValid(drive))
+    {
+        DOS_ERROR( ER_InvalidDrive, EC_MediaError, SA_Abort, EL_Disk );
+        return 0;
+    }
+
+#ifdef __svr4__
+    if (statfs( DOSDrives[drive].root, &info, 0, 0) < 0)
+#else
+    if (statfs( DOSDrives[drive].root, &info) < 0)
+#endif
+    {
+        FILE_SetDosError();
+        fprintf(stderr,"dosfs: cannot do statfs(%s)\n", DOSDrives[drive].root);
+        return 0;
+    }
+
+    *size = info.f_bsize * info.f_blocks;
+#ifdef __svr4__
+    *available = info.f_bfree * info.f_bsize;
+#else
+    *available = info.f_bavail * info.f_bsize;
+#endif
+    return 1;
+}
+
+
+/***********************************************************************
  *           GetDriveType   (KERNEL.136)
  */
 WORD GetDriveType( INT drive )
 {
     dprintf_dosfs( stddeb, "GetDriveType(%c:)\n", 'A' + drive );
-    if (!DRIVE_IsValid(drive)) return 0;
-    return DOSDrives[drive].type;
+    switch(DRIVE_GetType(drive))
+    {
+    case TYPE_FLOPPY:  return DRIVE_REMOVABLE;
+    case TYPE_HD:      return DRIVE_FIXED;
+    case TYPE_CDROM:   return DRIVE_REMOVABLE;
+    case TYPE_NETWORK: return DRIVE_REMOTE;
+    case TYPE_INVALID:
+    default:           return DRIVE_CANNOTDETERMINE;
+    }
 }
diff --git a/files/file.c b/files/file.c
index 19cc6fb..3d00a25 100644
--- a/files/file.c
+++ b/files/file.c
@@ -34,6 +34,7 @@
  */
 void FILE_SetDosError(void)
 {
+    dprintf_file(stddeb, "FILE_SetDosError: errno = %d\n", errno );
     switch (errno)
     {
     case EAGAIN:
@@ -44,18 +45,18 @@
         break;
     case ENOSPC:
         DOS_ERROR( ER_DiskFull, EC_MediaError, SA_Abort, EL_Disk );
-        break;				
+        break;
     case EACCES:
     case EPERM:
     case EROFS:
-        DOS_ERROR( ER_WriteProtected, EC_AccessDenied, SA_Abort, EL_Disk );
+        DOS_ERROR( ER_AccessDenied, EC_AccessDenied, SA_Abort, EL_Disk );
         break;
     case EBUSY:
         DOS_ERROR( ER_LockViolation, EC_AccessDenied, SA_Abort, EL_Disk );
-        break;		
+        break;
     case ENOENT:
         DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk );
-        break;				
+        break;
     case EISDIR:
         DOS_ERROR( ER_CanNotMakeDir, EC_AccessDenied, SA_Abort, EL_Unknown );
         break;
@@ -65,7 +66,7 @@
         break;
     case EEXIST:
         DOS_ERROR( ER_FileExists, EC_Exists, SA_Abort, EL_Disk );
-        break;				
+        break;
     default:
         perror( "int21: unknown errno" );
         DOS_ERROR( ER_GeneralFailure, EC_SystemFailure, SA_Abort, EL_Unknown );
@@ -98,6 +99,9 @@
         return -1;
     }
     *fp = (BYTE)handle;
+    dprintf_file(stddeb, 
+       "FILE_AllocTaskHandle: returning %d for handle %d file %d of %d \n", 
+                 (fp - files),handle,pdb->nbFiles - i, pdb->nbFiles  );
     return (HFILE)(fp - files);
 }
 
@@ -118,6 +122,8 @@
         exit(1);
     }
     files = PTR_SEG_TO_LIN( pdb->fileHandlesPtr );
+    dprintf_file( stddeb,"FILE_FreeTaskHandle: dos=%d unix=%d\n",
+                  handle, files[handle]);
     if ((handle<0) || (handle >= (INT)pdb->nbFiles) || (files[handle] == 0xff))
     {
         fprintf( stderr, "FILE_FreeTaskHandle: invalid file handle %d\n",
@@ -166,6 +172,7 @@
 
     if (!pdb) return;
     files = PTR_SEG_TO_LIN( pdb->fileHandlesPtr );
+    fprintf(stderr,"FILE_CloseAllFiles: closing %d files\n",pdb->nbFiles);
     for (count = pdb->nbFiles; count > 0; count--, files++)
     {
         if (*files != 0xff)
@@ -178,12 +185,46 @@
 
 
 /***********************************************************************
+ *           FILE_OpenUnixFile
+ */
+static int FILE_OpenUnixFile( const char *name, int mode )
+{
+    int handle;
+    struct stat st;
+
+    if ((handle = open( name, mode )) == -1)
+    {
+        if (Options.allowReadOnly && (mode == O_RDWR))
+        {
+            if ((handle = open( name, O_RDONLY )) != -1)
+                fprintf( stderr, "Warning: could not open %s for writing, opening read-only.\n", name );
+        }
+    }
+    if (handle != -1)  /* Make sure it's not a directory */
+    {
+        if ((fstat( handle, &st ) == -1))
+        {
+            FILE_SetDosError();
+            close( handle );
+            handle = -1;
+        }
+        else if (S_ISDIR(st.st_mode))
+        {
+            DOS_ERROR( ER_AccessDenied, EC_AccessDenied, SA_Abort, EL_Disk );
+            close( handle );
+            handle = -1;
+        }
+    }
+    return handle;
+}
+
+
+/***********************************************************************
  *           FILE_Open
  */
 int FILE_Open( LPCSTR path, int mode )
 {
     const char *unixName;
-    int handle;
 
     dprintf_file(stddeb, "FILE_Open: '%s' %04x\n", path, mode );
     if ((unixName = DOSFS_IsDevice( path )) != NULL)
@@ -191,26 +232,13 @@
         dprintf_file( stddeb, "FILE_Open: opening device '%s'\n", unixName );
         if (!unixName[0])  /* Non-existing device */
         {
+            dprintf_file(stddeb, "FILE_Open: Non-existing device\n");
             DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk );
             return -1;
         }
-        handle = open( unixName, mode );
     }
-    else
-    {
-        if (!(unixName = DOSFS_GetUnixFileName( path, TRUE ))) return -1;
-
-        if ((handle = open( unixName, mode )) == -1)
-        {
-            if (Options.allowReadOnly && (mode == O_RDWR))
-            {
-                if ((handle = open( unixName, O_RDONLY )) != -1)
-                    fprintf( stderr, "Warning: could not open %s for writing, opening read-only.\n", unixName );
-            }
-        }
-    }
-    if (handle == -1) FILE_SetDosError();
-    return handle;
+    else if (!(unixName = DOSFS_GetUnixFileName( path, TRUE ))) return -1;
+    return FILE_OpenUnixFile( unixName, mode );
 }
 
 
@@ -327,7 +355,7 @@
         DOS_ERROR( ER_AccessDenied, EC_AccessDenied, SA_Abort, EL_Disk );
         return 0;
     }
-    if (!(unixName = DOSFS_GetUnixFileName( path, TRUE ))) return 0;
+    if (!(unixName = DOSFS_GetUnixFileName( path, FALSE ))) return 0;
     if ((mkdir( unixName, 0777 ) == -1) && (errno != EEXIST))
     {
         FILE_SetDosError();
@@ -373,6 +401,7 @@
     HFILE dosHandle;
 
     if ((handle = FILE_GetUnixHandle( hFile )) == -1) return HFILE_ERROR;
+    dprintf_file( stddeb, "FILE_Dup for handle %d\n",handle);
     if ((newhandle = dup(handle)) == -1)
     {
         FILE_SetDosError();
@@ -380,6 +409,7 @@
     }
     if ((dosHandle = FILE_AllocTaskHandle( newhandle )) == HFILE_ERROR)
         close( newhandle );
+    dprintf_file( stddeb, "FILE_Dup return handle %d\n",dosHandle);
     return dosHandle;
 }
 
@@ -396,6 +426,7 @@
     int handle, newhandle;
 
     if ((handle = FILE_GetUnixHandle( hFile1 )) == -1) return HFILE_ERROR;
+    dprintf_file( stddeb, "FILE_Dup2 for handle %d\n",handle);
     if ((hFile2 < 0) || (hFile2 >= (INT)pdb->nbFiles))
     {
         DOS_ERROR( ER_InvalidHandle, EC_ProgramError, SA_Abort, EL_Disk );
@@ -414,8 +445,14 @@
         return HFILE_ERROR;
     }
     files = PTR_SEG_TO_LIN( pdb->fileHandlesPtr );
-    if (files[hFile2] != 0xff) close( files[hFile2] );
+    if (files[hFile2] != 0xff) 
+    {
+        dprintf_file( stddeb, "FILE_Dup2 closing old  handle2 %d\n",
+                      files[hFile2]);
+        close( files[hFile2] );
+    }
     files[hFile2] = (BYTE)newhandle;
+    dprintf_file( stddeb, "FILE_Dup2 return handle2 %d\n",newhandle);
     return hFile2;
 }
 
@@ -435,7 +472,7 @@
     ofs->cBytes = sizeof(OFSTRUCT);
     ofs->nErrCode = 0;
     if (mode & OF_REOPEN) name = ofs->szPathName;
-    dprintf_file( stddeb, "Openfile: %s %04x\n", name, mode );
+    dprintf_file( stddeb, "FILE_Openfile: %s %04x\n", name, mode );
 
     /* OF_PARSE simply fills the structure */
 
@@ -444,10 +481,12 @@
         if (!(dosName = DOSFS_GetDosTrueName( name, FALSE )))
         {
             ofs->nErrCode = DOS_ExtendedError;
+            dprintf_file( stddeb, "FILE_Openfile: %s  return = -1\n", name);
             return -1;
         }
         lstrcpyn( ofs->szPathName, dosName, sizeof(ofs->szPathName) );
         ofs->fFixedDisk = (GetDriveType( dosName[0]-'A' ) != DRIVE_REMOVABLE);
+        dprintf_file( stddeb, "FILE_Openfile: %s  return = 0\n", name);
         return 0;
     }
 
@@ -459,18 +498,21 @@
         if ((unixName = DOSFS_GetUnixFileName( name, FALSE )) == NULL)
         {
             ofs->nErrCode = DOS_ExtendedError;
+            dprintf_file( stddeb, "FILE_Openfile: %s  return = -1\n", name);
             return -1;
         }
-        dprintf_file( stddeb, "OpenFile: creating '%s'\n", unixName );
+        dprintf_file( stddeb, "FILE_OpenFile: creating '%s'\n", unixName );
         handle = open( unixName, O_TRUNC | O_RDWR | O_CREAT, 0666 );
         if (handle == -1)
         {
             FILE_SetDosError();
             ofs->nErrCode = DOS_ExtendedError;
+            dprintf_file( stddeb, "FILE_Openfile: %s  return = -1\n", name);
             return -1;
         }   
         lstrcpyn( ofs->szPathName, DOSFS_GetDosTrueName( name, FALSE ),
                   sizeof(ofs->szPathName) );
+        dprintf_file( stddeb, "FILE_Openfile: %s  return = %d \n", name, handle);
         return handle;
     }
 
@@ -540,21 +582,26 @@
     }
 
 not_found:
-    dprintf_file( stddeb, "OpenFile: '%s' not found\n", name );
+    dprintf_file( stddeb, "FILE_OpenFile: '%s' not found\n", name );
     DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk );
     ofs->nErrCode = ER_FileNotFound;
+    dprintf_file( stddeb, "FILE_Openfile: %s  return =-1\n", name);
     return -1;
 
 found:
-    dprintf_file( stddeb, "OpenFile: found '%s'\n", unixName );
+    dprintf_file( stddeb, "FILE_OpenFile: found '%s'\n", unixName );
     lstrcpyn( ofs->szPathName, DOSFS_GetDosTrueName( ofs->szPathName, FALSE ),
               sizeof(ofs->szPathName) );
 
-    if (mode & OF_PARSE) return 0;
-
+    if (mode & OF_PARSE) 
+    {
+          dprintf_file( stddeb, "FILE_Openfile: %s  return = 0\n", name);
+          return 0;
+    }
     if (mode & OF_DELETE)
     {
         if (unlink( unixName ) == -1) goto not_found;
+        dprintf_file( stddeb, "FILE_Openfile: %s  return = 0\n", name);
         return 0;
     }
 
@@ -569,27 +616,24 @@
         unixMode = O_RDONLY; break;
     }
 
-    if ((handle = open( unixName, unixMode )) == -1)
-    {
-        if (Options.allowReadOnly && (unixMode == O_RDWR))
-        {
-            if ((handle = open( unixName, O_RDONLY )) != -1)
-                fprintf( stderr, "Warning: could not open %s for writing, opening read-only.\n", unixName );
-        }
-    }
-    if (handle == -1) goto not_found;
+    if ((handle = FILE_OpenUnixFile( unixName, unixMode )) == -1)
+        goto not_found;
 
     if (fstat( handle, &st ) != -1)
     {
         if ((mode & OF_VERIFY) && (mode & OF_REOPEN))
         {
             if (memcmp( ofs->reserved, &st.st_mtime, sizeof(ofs->reserved) ))
+            {
+                dprintf_file( stddeb, "FILE_Openfile: %s  return = -1\n", name);
                 return -1;
+            }
         }
         memcpy( ofs->reserved, &st.st_mtime, sizeof(ofs->reserved) );
     }
 
     if (mode & OF_EXIST) close( handle );
+    dprintf_file( stddeb, "FILE_Openfile: %s  return = %d\n", name,handle);
 
     return handle;
 }
@@ -654,6 +698,7 @@
     int unixHandle;
     HFILE handle;
 
+    dprintf_file( stddeb, "OpenFile %s \n",name);
     if ((unixHandle = FILE_OpenFile( name, ofs, mode )) == -1)
         return HFILE_ERROR;
     if ((handle = FILE_AllocTaskHandle( unixHandle )) == HFILE_ERROR)
@@ -673,9 +718,9 @@
 {
     int handle;
 
-    dprintf_file( stddeb, "_lclose: handle %d\n", hFile );
     
     if ((handle = FILE_GetUnixHandle( hFile )) == -1) return HFILE_ERROR;
+    dprintf_file( stddeb, "_lclose: doshandle %d unixhandle %d\n", hFile,handle );
     if (handle <= 2)
     {
         fprintf( stderr, "_lclose: internal error: closing handle %d\n", handle );
@@ -738,7 +783,7 @@
 LONG _llseek( HFILE hFile, LONG lOffset, INT nOrigin )
 {
     int handle, origin, result;
-	
+
     dprintf_file( stddeb, "_llseek: handle %d, offset %ld, origin %d\n", 
                   hFile, lOffset, nOrigin);
 
@@ -805,10 +850,10 @@
 
     dprintf_file( stddeb, "_hread: %d %p %ld\n", hFile, buffer, count );
   
-    if ((handle = FILE_GetUnixHandle( hFile )) == -1) return HFILE_ERROR;
+    if ((handle = FILE_GetUnixHandle( hFile )) == -1) return -1;
     if (!count) return 0;
     if ((result = read( handle, buffer, count )) == -1) FILE_SetDosError();
-    return (result == -1) ? HFILE_ERROR : result;
+    return result;
 }
 
 
diff --git a/files/profile.c b/files/profile.c
new file mode 100644
index 0000000..50816e1
--- /dev/null
+++ b/files/profile.c
@@ -0,0 +1,686 @@
+/*
+ * Profile functions
+ *
+ * Copyright 1993 Miguel de Icaza
+ * Copyright 1996 Alexandre Julliard
+ */
+
+#include <ctype.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "dos_fs.h"
+#include "windows.h"
+#include "xmalloc.h"
+#include "stddebug.h"
+#include "debug.h"
+
+typedef struct tagPROFILEKEY
+{
+    char                  *name;
+    char                  *value;
+    struct tagPROFILEKEY  *next;
+} PROFILEKEY;
+
+typedef struct tagPROFILESECTION
+{
+    char                       *name;
+    struct tagPROFILEKEY       *key;
+    struct tagPROFILESECTION   *next;
+} PROFILESECTION; 
+
+
+typedef struct
+{
+    int              changed;
+    PROFILESECTION  *section;
+    char            *dos_name;
+} PROFILE;
+
+
+/* Cached profile file */
+static PROFILE CurProfile = { FALSE, NULL, NULL };
+
+/* wine.ini profile content */
+static PROFILESECTION *WineProfile;
+
+#define PROFILE_MAX_LINE_LEN   1024
+
+/* Wine profile name in $HOME directory; must begin with slash */
+static const char PROFILE_WineIniName[] = "/.winerc";
+
+/* Check for comments in profile */
+#define IS_ENTRY_COMMENT(str)  ((str)[0] == ';')
+
+
+/***********************************************************************
+ *           PROFILE_CopyEntry
+ *
+ * Copy the content of an entry into a buffer, removing quotes, and possibly
+ * translating environment variables.
+ */
+static void PROFILE_CopyEntry( char *buffer, const char *value, int len,
+                               int handle_env )
+{
+    char quote = '\0';
+    const char *p;
+
+    if ((*value == '\'') || (*value == '\"'))
+    {
+        if (value[1] && (value[strlen(value)-1] == *value)) quote = *value++;
+    }
+
+    if (!handle_env)
+    {
+        lstrcpyn( buffer, value, len );
+        if (quote && (len >= strlen(value))) buffer[strlen(buffer)-1] = '\0';
+        return;
+    }
+
+    for (p = value; (*p && (len > 1)); *buffer++ = *p++, len-- )
+    {
+        if ((*p == '$') && (p[1] == '{'))
+        {
+            char env_val[1024];
+            const char *env_p;
+            const char *p2 = strchr( p, '}' );
+            if (!p2) continue;  /* ignore it */
+            lstrcpyn( env_val, p + 2, MIN( sizeof(env_val), (int)(p2-p)-1 ) );
+            if ((env_p = getenv( env_val )) != NULL)
+            {
+                lstrcpyn( buffer, env_p, len );
+                buffer += strlen( buffer );
+                len -= strlen( buffer );
+            }
+            p = p2 + 1;
+        }
+    }
+    *buffer = '\0';
+}
+
+
+/***********************************************************************
+ *           PROFILE_Save
+ *
+ * Save a profile tree to a file.
+ */
+static void PROFILE_Save( FILE *file, PROFILESECTION *section )
+{
+    PROFILEKEY *key;
+
+    for ( ; section; section = section->next)
+    {
+        if (section->name) fprintf( file, "[%s]\n", section->name );
+        for (key = section->key; key; key = key->next)
+        {
+            fprintf( file, "%s", key->name );
+            if (key->value) fprintf( file, "=%s", key->value );
+            fprintf( file, "\n" );
+        }
+    }
+}
+
+
+/***********************************************************************
+ *           PROFILE_Free
+ *
+ * Free a profile tree.
+ */
+static void PROFILE_Free( PROFILESECTION *section )
+{
+    PROFILESECTION *next_section;
+    PROFILEKEY *key, *next_key;
+
+    for ( ; section; section = next_section)
+    {
+        if (section->name) free( section->name );
+        for (key = section->key; key; key = next_key)
+        {
+            next_key = key->next;
+            if (key->name) free( key->name );
+            if (key->value) free( key->value );
+            free( key );
+        }
+        next_section = section->next;
+        free( section );
+    }
+}
+
+
+/***********************************************************************
+ *           PROFILE_Load
+ *
+ * Load a profile tree from a file.
+ */
+static PROFILESECTION *PROFILE_Load( FILE *file )
+{
+    char buffer[PROFILE_MAX_LINE_LEN];
+    char *p, *p2;
+    int line = 0;
+    PROFILESECTION *section, *first_section;
+    PROFILESECTION **prev_section;
+    PROFILEKEY *key, **prev_key;
+
+    first_section = (PROFILESECTION *)xmalloc( sizeof(*section) );
+    first_section->name = NULL;
+    first_section->key  = NULL;
+    first_section->next = NULL;
+    prev_section = &first_section->next;
+    prev_key     = &first_section->key;
+
+    while (fgets( buffer, PROFILE_MAX_LINE_LEN, file ))
+    {
+        line++;
+        p = buffer + strlen(buffer) - 1;
+        while ((p > buffer) && ((*p == '\n') || isspace(*p))) *p-- = '\0';
+        p = buffer;
+        while (*p && isspace(*p)) p++;
+        if (*p == '[')  /* section start */
+        {
+            if (!(p2 = strrchr( p, ']' )))
+            {
+                fprintf( stderr, "PROFILE_Load: Invalid section header at line %d: '%s'\n",
+                         line, p );
+            }
+            else
+            {
+                *p2 = '\0';
+                p++;
+                section = (PROFILESECTION *)xmalloc( sizeof(*section));
+                section->name = xstrdup( p );
+                section->key  = NULL;
+                section->next = NULL;
+                *prev_section = section;
+                prev_section  = &section->next;
+                prev_key      = &section->key;
+                continue;
+            }
+        }
+        if ((p2 = strchr( p, '=' )) != NULL)
+        {
+            char *p3 = p2 - 1;
+            while ((p3 > p) && isspace(*p3)) *p3-- = '\0';
+            *p2++ = '\0';
+            while (*p2 && isspace(*p2)) p2++;
+        }
+        key = (PROFILEKEY *)xmalloc( sizeof(*key) );
+        key->name  = xstrdup( p );
+        key->value = p2 ? xstrdup( p2 ) : NULL;
+        key->next  = NULL;
+        *prev_key  = key;
+        prev_key = &key->next;
+    }
+    if (debugging_profile)
+    {
+        fprintf( stddeb, "PROFILE_Load:\n" );
+        PROFILE_Save( stddeb, first_section );
+        fprintf( stddeb, "PROFILE_Load finished.\n" );
+    }
+    return first_section;
+}
+
+
+/***********************************************************************
+ *           PROFILE_DeleteSection
+ *
+ * Delete a section from a profile tree.
+ */
+static BOOL PROFILE_DeleteSection( PROFILESECTION **section, const char *name )
+{
+    while (*section)
+    {
+        if ((*section)->name && !lstrcmpi( (*section)->name, name ))
+        {
+            PROFILESECTION *to_del = *section;
+            *section = to_del->next;
+            to_del->next = NULL;
+            PROFILE_Free( to_del );
+            return TRUE;
+        }
+        section = &(*section)->next;
+    }
+    return FALSE;
+}
+
+
+/***********************************************************************
+ *           PROFILE_DeleteKey
+ *
+ * Delete a key from a profile tree.
+ */
+static BOOL PROFILE_DeleteKey( PROFILESECTION **section,
+                               const char *section_name, const char *key_name )
+{
+    while (*section)
+    {
+        if ((*section)->name && !lstrcmpi( (*section)->name, section_name ))
+        {
+            PROFILEKEY **key = &(*section)->key;
+            while (*key)
+            {
+                if (!lstrcmpi( (*key)->name, key_name ))
+                {
+                    PROFILEKEY *to_del = *key;
+                    *key = to_del->next;
+                    if (to_del->name) free( to_del->name );
+                    if (to_del->value) free( to_del->value );
+                    free( to_del );
+                    return TRUE;
+                }
+                key = &(*key)->next;
+            }
+        }
+        section = &(*section)->next;
+    }
+    return FALSE;
+}
+
+
+/***********************************************************************
+ *           PROFILE_Find
+ *
+ * Find a key in a profile tree, optionally creating it.
+ */
+static PROFILEKEY *PROFILE_Find( PROFILESECTION **section,
+                                 const char *section_name,
+                                 const char *key_name, int create )
+{
+    while (*section)
+    {
+        if ((*section)->name && !lstrcmpi( (*section)->name, section_name ))
+        {
+            PROFILEKEY **key = &(*section)->key;
+            while (*key)
+            {
+                if (!lstrcmpi( (*key)->name, key_name )) return *key;
+                key = &(*key)->next;
+            }
+            if (!create) return NULL;
+            *key = (PROFILEKEY *)xmalloc( sizeof(PROFILEKEY) );
+            (*key)->name  = xstrdup( key_name );
+            (*key)->value = NULL;
+            (*key)->next  = NULL;
+            return *key;
+        }
+        section = &(*section)->next;
+    }
+    if (!create) return NULL;
+    *section = (PROFILESECTION *)xmalloc( sizeof(PROFILESECTION) );
+    (*section)->name = xstrdup(section_name);
+    (*section)->next = NULL;
+    (*section)->key  = (PROFILEKEY *)xmalloc( sizeof(PROFILEKEY) );
+    (*section)->key->name  = xstrdup( key_name );
+    (*section)->key->value = NULL;
+    (*section)->key->next  = NULL;
+    return (*section)->key;
+}
+
+
+/***********************************************************************
+ *           PROFILE_FlushFile
+ *
+ * Flush the current profile to disk if changed.
+ */
+static BOOL PROFILE_FlushFile(void)
+{
+    char *p, buffer[MAX_PATHNAME_LEN];
+    const char *unix_name;
+    FILE *file = NULL;
+
+    if (!CurProfile.changed || !CurProfile.dos_name) return TRUE;
+    if (!(unix_name = DOSFS_GetUnixFileName( CurProfile.dos_name, FALSE )) ||
+        !(file = fopen( unix_name, "w" )))
+    {
+        /* Try to create it in $HOME/.wine */
+        /* FIXME: this will need a more general solution */
+        if ((p = getenv( "HOME" )) != NULL)
+        {
+            strcpy( buffer, p );
+            strcat( buffer, "/.wine/" );
+            p = buffer + strlen(buffer);
+            strcpy( p, strrchr( CurProfile.dos_name, '\\' ) + 1 );
+            AnsiLower( p );
+            file = fopen( buffer, "w" );
+            unix_name = buffer;
+        }
+    }
+    
+    if (!file)
+    {
+        fprintf( stderr, "Warning: could not save profile file %s\n",
+                 CurProfile.dos_name );
+        return FALSE;
+    }
+
+    dprintf_profile( stddeb, "Saving '%s' into '%s'\n",
+                     CurProfile.dos_name, unix_name );
+    PROFILE_Save( file, CurProfile.section );
+    fclose( file );
+    CurProfile.changed = FALSE;
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *           PROFILE_Open
+ *
+ * Open a profile file, checking the cached file first.
+ */
+static BOOL PROFILE_Open( const char *filename )
+{
+    char buffer[MAX_PATHNAME_LEN];
+    const char *dos_name, *unix_name;
+    char *newdos_name, *p;
+    FILE *file = NULL;
+
+    if (strchr( filename, '/' ) || strchr( filename, '\\' ) || 
+        strchr( filename, ':' ))
+    {
+        if (!(dos_name = DOSFS_GetDosTrueName( filename, FALSE))) return FALSE;
+    }
+    else
+    {
+        GetWindowsDirectory( buffer, sizeof(buffer) );
+        strcat( buffer, "\\" );
+        strcat( buffer, filename );
+        if (!(dos_name = DOSFS_GetDosTrueName( buffer, FALSE ))) return FALSE;
+    }
+    if (CurProfile.dos_name && !strcmp( dos_name, CurProfile.dos_name ))
+    {
+        dprintf_profile( stddeb, "PROFILE_Open(%s): already opened\n",
+                         filename );
+        return TRUE;
+    }
+
+    /* Flush the previous profile */
+
+    newdos_name = xstrdup( dos_name );
+    PROFILE_FlushFile();
+    PROFILE_Free( CurProfile.section );
+    if (CurProfile.dos_name) free( CurProfile.dos_name );
+    CurProfile.section   = NULL;
+    CurProfile.dos_name  = newdos_name;
+
+    /* Try to open the profile file, first in $HOME/.wine */
+
+    /* FIXME: this will need a more general solution */
+    if ((p = getenv( "HOME" )) != NULL)
+    {
+        strcpy( buffer, p );
+        strcat( buffer, "/.wine/" );
+        p = buffer + strlen(buffer);
+        strcpy( p, strrchr( newdos_name, '\\' ) + 1 );
+        AnsiLower( p );
+        if ((file = fopen( buffer, "r" )))
+            dprintf_profile( stddeb, "Found it in %s\n", buffer );
+    }
+
+    if (!file && ((unix_name = DOSFS_GetUnixFileName( dos_name, TRUE ))))
+    {
+        if ((file = fopen( unix_name, "r" )))
+            dprintf_profile( stddeb, "Found it in %s\n", unix_name );
+    }
+
+    if (file)
+    {
+        CurProfile.section = PROFILE_Load( file );
+        fclose( file );
+    }
+    else
+        fprintf( stderr, "Warning: profile file %s not found\n", newdos_name );
+    dprintf_profile( stddeb, "PROFILE_Open(%s): successful\n", filename );
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *           PROFILE_GetSection
+ *
+ * Enumerate all the keys of a section.
+ */
+static INT PROFILE_GetSection( PROFILESECTION *section,
+                               const char *section_name,
+                               char *buffer, INT len, int handle_env )
+{
+    PROFILEKEY *key;
+    while (section)
+    {
+        if (section->name && !lstrcmpi( section->name, section_name ))
+        {
+            for (key = section->key; key; key = key->next)
+            {
+                if (len <= 2) break;
+                if (IS_ENTRY_COMMENT(key->name)) continue;  /* Skip comments */
+                PROFILE_CopyEntry( buffer, key->name, len - 1, handle_env );
+                len -= strlen(buffer) - 1;
+                buffer += strlen(buffer) + 1;
+            }
+            *buffer = '\0';
+            return len - 1;
+        }
+        section = section->next;
+    }
+    buffer[0] = buffer[1] = '\0';
+    return len - 2;
+}
+
+
+/***********************************************************************
+ *           PROFILE_GetString
+ *
+ * Get a profile string.
+ */
+static INT PROFILE_GetString( const char *section, const char *key_name,
+                              const char *def_val, char *buffer, INT len )
+{
+    PROFILEKEY *key = NULL;
+
+    if (!def_val) def_val = "";
+    if (key_name)
+    {
+        key = PROFILE_Find( &CurProfile.section, section, key_name, FALSE );
+        PROFILE_CopyEntry( buffer, (key && key->value) ? key->value : def_val,
+                           len, FALSE );
+        dprintf_profile( stddeb, "PROFILE_GetString('%s','%s','%s'): returning '%s'\n",
+                         section, key_name, def_val, buffer );
+        return strlen( buffer );
+    }
+    return PROFILE_GetSection(CurProfile.section, section, buffer, len, FALSE);
+}
+
+
+/***********************************************************************
+ *           PROFILE_SetString
+ *
+ * Set a profile string.
+ */
+static BOOL PROFILE_SetString( const char *section_name, const char *key_name,
+                               const char *value )
+{
+    BOOL ret;
+
+    if (!key_name)  /* Delete a whole section */
+    {
+        dprintf_profile(stddeb, "PROFILE_DeleteSection('%s')\n", section_name);
+        ret = PROFILE_DeleteSection( &CurProfile.section, section_name );
+        CurProfile.changed |= ret;
+        return ret;
+    }
+    else if (!value)  /* Delete a key */
+    {
+        dprintf_profile( stddeb, "PROFILE_DeleteKey('%s','%s')\n",
+                         section_name, key_name );
+        ret = PROFILE_DeleteKey( &CurProfile.section, section_name, key_name );
+        CurProfile.changed |= ret;
+        return ret;
+    }
+    else  /* Set the key value */
+    {
+        PROFILEKEY *key = PROFILE_Find( &CurProfile.section, section_name,
+                                        key_name, TRUE );
+        dprintf_profile( stddeb, "PROFILE_SetString('%s','%s','%s'): ",
+                         section_name, key_name, value );
+        if (key->value)
+        {
+            if (!strcmp( key->value, value ))
+            {
+                dprintf_profile( stddeb, "no change needed\n" );
+                return TRUE;  /* No change needed */
+            }
+            dprintf_profile( stddeb, "replacing '%s'\n", key->value );
+            free( key->value );
+        }
+        else dprintf_profile( stddeb, "creating key\n" );
+        key->value = xstrdup( value );
+        CurProfile.changed = TRUE;
+        return TRUE;
+    }
+}
+
+
+/***********************************************************************
+ *           PROFILE_GetWineIniString
+ *
+ * Get a config string from the wine.ini file.
+ */
+int PROFILE_GetWineIniString( const char *section, const char *key_name,
+                              const char *def, char *buffer, int len )
+{
+    if (key_name)
+    {
+        PROFILEKEY *key = PROFILE_Find(&WineProfile, section, key_name, FALSE);
+        PROFILE_CopyEntry( buffer, (key && key->value) ? key->value : def,
+                           len, TRUE );
+        dprintf_profile( stddeb, "PROFILE_GetWineIniString('%s','%s','%s'): returning '%s'\n",
+                         section, key_name, def, buffer );
+        return strlen( buffer );
+    }
+    return PROFILE_GetSection( WineProfile, section, buffer, len, TRUE );
+}
+
+
+/***********************************************************************
+ *           PROFILE_LoadWineIni
+ *
+ * Load the wine.ini file.
+ */
+int PROFILE_LoadWineIni(void)
+{
+    char buffer[MAX_PATHNAME_LEN];
+    const char *p;
+    FILE *f;
+
+    if ((p = getenv( "HOME" )) != NULL)
+    {
+        lstrcpyn( buffer, p, MAX_PATHNAME_LEN - sizeof(PROFILE_WineIniName) );
+        strcat( buffer, PROFILE_WineIniName );
+        if ((f = fopen( buffer, "r" )) != NULL)
+        {
+            WineProfile = PROFILE_Load( f );
+            fclose( f );
+            return 1;
+        }
+    }
+    else fprintf( stderr, "Warning: could not get $HOME value for config file.\n" );
+
+    /* Try global file */
+
+    if ((f = fopen( WINE_INI_GLOBAL, "r" )) != NULL)
+    {
+        WineProfile = PROFILE_Load( f );
+        fclose( f );
+        return 1;
+    }
+    fprintf( stderr, "Can't open configuration file %s or $HOME%s\n",
+             WINE_INI_GLOBAL, PROFILE_WineIniName );
+    return 0;
+}
+
+
+/***********************************************************************
+ *           GetProfileInt   (KERNEL.57)
+ */
+UINT GetProfileInt( LPCSTR section, LPCSTR entry, INT def_val )
+{
+    return GetPrivateProfileInt( section, entry, def_val, "win.ini" );
+}
+
+
+/***********************************************************************
+ *           GetProfileString   (KERNEL.58)
+ */
+INT GetProfileString( LPCSTR section, LPCSTR entry, LPCSTR def_val,
+                      LPSTR buffer, INT len )
+{
+    return GetPrivateProfileString( section, entry, def_val,
+                                    buffer, len, "win.ini" );
+}
+
+
+/***********************************************************************
+ *           WriteProfileString   (KERNEL.59)
+ */
+BOOL WriteProfileString( LPCSTR section, LPCSTR entry, LPCSTR string )
+{
+    return WritePrivateProfileString( section, entry, string, "win.ini" );
+}
+
+
+/***********************************************************************
+ *           GetPrivateProfileInt   (KERNEL.127)
+ */
+UINT GetPrivateProfileInt( LPCSTR section, LPCSTR entry, INT def_val,
+                           LPCSTR filename )
+{
+    char buffer[20];
+    char *p;
+    long result;
+
+    GetPrivateProfileString( section, entry, "",
+                             buffer, sizeof(buffer), filename );
+    if (!buffer[0]) return (UINT)def_val;
+    result = strtol( buffer, &p, 0 );
+    if (p == buffer) return 0;  /* No digits at all */
+#ifdef WINELIB32
+    return (UINT)result;
+#else
+    if (result > 65535) return 65535;
+    if (result >= 0) return (UINT)result;
+    if (result < -32768) return -32768;
+    return (UINT)(INT)result;
+#endif
+}
+
+
+/***********************************************************************
+ *           GetPrivateProfileString   (KERNEL.128)
+ */
+INT GetPrivateProfileString( LPCSTR section, LPCSTR entry, LPCSTR def_val,
+                             LPSTR buffer, INT len, LPCSTR filename )
+{
+    if (PROFILE_Open( filename ))
+        return PROFILE_GetString( section, entry, def_val, buffer, len );
+    lstrcpyn( buffer, def_val, len );
+    return strlen( buffer );
+}
+
+
+/***********************************************************************
+ *           WritePrivateProfileString   (KERNEL.129)
+ */
+BOOL WritePrivateProfileString( LPCSTR section, LPCSTR entry, LPCSTR string,
+                                LPCSTR filename )
+{
+    if (!PROFILE_Open( filename )) return FALSE;
+    if (!section) return PROFILE_FlushFile();
+    return PROFILE_SetString( section, entry, string );
+}
+
+
+/***********************************************************************
+ *           WriteOutProfiles   (KERNEL.315)
+ */
+void WriteOutProfiles(void)
+{
+    PROFILE_FlushFile();
+}