Adding upstream version 1:10.5.12.upstream/1%10.5.12upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1405 insertions, 0 deletions

diff --git a/storage/connect/inihandl.cpp b/storage/connect/inihandl.cpp
new file mode 100644
index 00000000..c39c94fb
--- /dev/null
+++ b/storage/connect/inihandl.cpp
@@ -0,0 +1,1405 @@
+/*
+ * Profile functions
+ *
+ * Copyright 1993 Miguel de Icaza
+ * Copyright 1996 Alexandre Julliard
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA
+ */
+#include "my_global.h"
+
+#include <ctype.h>
+//#include <errno.h>
+#include <fcntl.h>
+//#include <io.h>  commented this line out to compile for solaris
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <sys/stat.h>
+//#include <sys/types.h>
+//#include <memory.h>
+#include "osutil.h"
+#include "global.h"
+#include "inihandl.h"
+
+// The types and variables used locally
+//typedef int bool;
+typedef unsigned int uint;
+//#define SVP(S)  ((S) ? S : "<null>")
+#define _strlwr(P)  strlwr(P)  //OB: changed this line
+#define MAX_PATHNAME_LEN  256
+#define N_CACHED_PROFILES  10
+#ifndef WIN32
+#define stricmp    strcasecmp
+#define _strnicmp  strncasecmp
+#endif // !WIN32
+#define EnterCriticalSection(x)
+#define LeaveCriticalSection(x)
+
+#if defined(TEST_MODULE)
+// Stand alone test program
+#include <stdarg.h>
+        int trace = 0;
+void    htrc(char const *fmt, ...)
+{
+  va_list ap;
+  va_start (ap, fmt);
+  vfprintf(stderr, fmt, ap);
+  va_end (ap);
+} /* end of htrc */
+#else   // !TEST_MODULE
+// Normal included functions
+//extern  int trace;
+//void    htrc(char const *fmt, ...);
+#endif  // !TEST MODULE
+
+
+typedef struct tagPROFILEKEY {
+  char                 *value;
+  struct tagPROFILEKEY *next;
+  char                  name[1];
+  } PROFILEKEY;
+
+typedef struct tagPROFILESECTION {
+  struct tagPROFILEKEY     *key;
+  struct tagPROFILESECTION *next;
+  char                      name[1];
+  } PROFILESECTION;
+
+typedef struct {
+  BOOL             changed;
+  PROFILESECTION  *section;
+//char            *dos_name;
+//char            *unix_name;
+  char            *filename;
+  time_t           mtime;
+  } PROFILE;
+
+#define memfree(P)   if (P) free(P)
+
+/* Cached profile files */
+static PROFILE *MRUProfile[N_CACHED_PROFILES] = {NULL};
+
+#define CurProfile (MRUProfile[0])
+
+/* wine.ini config file registry root */
+//static HKEY wine_profile_key;
+
+#define PROFILE_MAX_LINE_LEN   1024
+
+/* Wine profile name in $HOME directory; must begin with slash */
+//static const char PROFILE_WineIniName[] = "/.winerc";
+
+/* Wine profile: the profile file being used */
+//static char PROFILE_WineIniUsed[MAX_PATHNAME_LEN] = "";
+
+/* Check for comments in profile */
+#define IS_ENTRY_COMMENT(str)  ((str)[0] == ';')
+
+//static const WCHAR wininiW[] = { 'w','i','n','.','i','n','i',0 };
+
+//static CRITICAL_SECTION PROFILE_CritSect = CRITICAL_SECTION_INIT("PROFILE_CritSect");
+
+BOOL  WritePrivateProfileString(LPCSTR section, LPCSTR entry,
+                                LPCSTR string, LPCSTR filename);
+
+/***********************************************************************
+ *           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, uint len,
+                               int handle_env )
+{
+  const char *p;
+  char quote = '\0';
+
+  if (!buffer)
+    return;
+
+  if ((*value == '\'') || (*value == '\"'))
+    if (value[1] && (value[strlen(value)-1] == *value))
+      quote = *value++;
+
+  if (!handle_env) {
+    strncpy(buffer, value, len);
+
+    if (quote && (len >= strlen(value)))
+      buffer[strlen(buffer)-1] = '\0';
+
+    return;
+    } // endif handle
+
+  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 */
+
+      strncpy(env_val, p + 2, MY_MIN((int) sizeof(env_val), (int)(p2-p)-1));
+
+      if ((env_p = getenv(env_val)) != NULL) {
+        int buffer_len;
+
+        strncpy( buffer, env_p, len );
+        buffer_len = strlen( buffer );
+        buffer += buffer_len;
+        len -= buffer_len;
+        } // endif env_p
+
+      p = p2 + 1;
+      } // endif p
+
+    } // endfor p
+
+  if (quote && (len > 1))
+    buffer--;
+
+  *buffer = '\0';
+}  // end of PROFILE_CopyEntry
+
+
+/***********************************************************************
+ *           PROFILE_Save
+ *
+ * Save a profile tree to a file.
+ ***********************************************************************/
+static void PROFILE_Save( FILE *file, PROFILESECTION *section )
+{
+  PROFILEKEY *key;
+  int secno;
+
+  for (secno= 0; section; section= section->next) {
+    if (section->name[0]) {
+      fprintf(file, "%s[%s]\n", secno ? "\n" : "", SVP(section->name));
+      secno++;
+    }
+
+    for (key = section->key; key; key = key->next)
+      if (key->name[0]) {
+        fprintf(file, "%s", SVP(key->name));
+
+        if (key->value)
+          fprintf(file, "=%s", SVP(key->value));
+
+        fprintf(file, "\n");
+        } // endif key->name
+
+    }  // endfor section
+
+} // end of PROFILE_Save
+
+
+/***********************************************************************
+ *           PROFILE_Free
+ *
+ * Free a profile tree.
+ ***********************************************************************/
+static void PROFILE_Free( PROFILESECTION *section )
+{
+  PROFILESECTION *next_section;
+  PROFILEKEY *key, *next_key;
+
+  for (; section; section = next_section) {
+    for (key = section->key; key; key = next_key) {
+      next_key = key->next;
+      memfree(key->value);
+      free(key);
+      }  // endfor key
+
+    next_section = section->next;
+    free(section);
+    } // endfor section
+
+} // end of PROFILE_Free
+
+static int PROFILE_isspace(char c)
+{
+  /* CR and ^Z (DOS EOF) are spaces too  (found on CD-ROMs) */
+  if (isspace(c) || c=='\r' || c==0x1a)
+    return 1;
+
+  return 0;
+} // end of PROFILE_isspace
+
+
+/***********************************************************************
+ *           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* *next_section;
+  PROFILEKEY      *key, *prev_key, **next_key;
+
+  first_section = (PROFILESECTION*)malloc(sizeof(*section));
+
+  if (first_section == NULL)
+    return NULL;
+
+  first_section->name[0] = 0;
+  first_section->key  = NULL;
+  first_section->next = NULL;
+  next_section = &first_section->next;
+  next_key     = &first_section->key;
+  prev_key     = NULL;
+
+  while (fgets(buffer, PROFILE_MAX_LINE_LEN, file)) {
+    line++;
+    p = buffer;
+
+    while (*p && PROFILE_isspace(*p))
+      p++;
+
+    if (*p == '[') {  /* section start */
+      if (!(p2 = strrchr( p, ']'))) {
+        fprintf(stderr, "Invalid section header at line %d: '%s'\n",
+                line, p);
+      }  else {
+        *p2 = '\0';
+        p++;
+
+        if (!(section = (PROFILESECTION*)malloc(sizeof(*section) + strlen(p))))
+          break;
+
+        strcpy(section->name, p);
+        section->key  = NULL;
+        section->next = NULL;
+        *next_section = section;
+        next_section  = &section->next;
+        next_key      = &section->key;
+        prev_key      = NULL;
+
+        if (trace(2))
+          htrc("New section: '%s'\n",section->name);
+
+        continue;
+      }  // endif p2
+
+      }  // endif p
+
+    p2 = p + strlen(p) - 1;
+
+    while ((p2 > p) && ((*p2 == '\n') || PROFILE_isspace(*p2)))
+      *p2-- = '\0';
+
+    if ((p2 = strchr(p, '=')) != NULL) {
+      char *p3 = p2 - 1;
+
+      while ((p3 > p) && PROFILE_isspace(*p3))
+        *p3-- = '\0';
+
+      *p2++ = '\0';
+
+      while (*p2 && PROFILE_isspace(*p2))
+        p2++;
+
+      } // endif p2
+
+    if (*p || !prev_key || *prev_key->name) {
+      if (!(key = (PROFILEKEY*)malloc(sizeof(*key) + strlen(p))))
+        break;
+
+      strcpy(key->name, p);
+
+      if (p2) {
+        key->value = (char*)malloc(strlen(p2)+1);
+        strcpy(key->value, p2);
+      } else
+        key->value = NULL;
+
+      key->next = NULL;
+      *next_key = key;
+      next_key  = &key->next;
+      prev_key  = key;
+
+      if (trace(2))
+        htrc("New key: name='%s', value='%s'\n",
+              key->name,key->value?key->value:"(none)");
+
+      } // endif p || prev_key
+
+    } // endif *p
+
+  return first_section;
+} // end of PROFILE_Load
+
+/***********************************************************************
+ *           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;
+  struct stat buf;
+  
+  if (trace(2))
+    htrc("PROFILE_FlushFile: CurProfile=%p\n", CurProfile);
+
+  if (!CurProfile) {
+    fprintf(stderr, "No current profile!\n");
+    return FALSE;
+    } // endif !CurProfile
+
+  if (!CurProfile->changed || !CurProfile->filename)
+    return TRUE;
+
+#if 0
+  if (!(file = fopen(unix_name, "w"))) {
+    /* Try to create it in $HOME/.wine */
+    /* FIXME: this will need a more general solution */
+    //strcpy( buffer, get_config_dir() );
+    //p = buffer + strlen(buffer);
+    //*p++ = '/';
+    char *p1 = strrchr(CurProfile->filename, '\\');
+
+    p = buffer;              // OB: To be elaborate
+
+    if (p1) 
+      p1++;
+    else
+      p1 = CurProfile->dos_name;
+
+    strcpy(p, p1);
+    _strlwr(p);
+    file = fopen(buffer, "w");
+    unix_name = buffer;
+    }  // endif !unix_name
+#endif // 0
+
+  if (!(file = fopen(CurProfile->filename, "w"))) {
+    fprintf(stderr, "could not save profile file %s\n", CurProfile->filename);
+    return FALSE;
+    } // endif !file
+
+  if (trace(2))
+    htrc("Saving '%s'\n", CurProfile->filename);
+
+  PROFILE_Save(file, CurProfile->section);
+  fclose(file);
+  CurProfile->changed = FALSE;
+
+  if (!stat(CurProfile->filename, &buf))
+    CurProfile->mtime = buf.st_mtime;
+
+  return TRUE;
+}  // end of PROFILE_FlushFile
+
+
+/***********************************************************************
+ *           PROFILE_ReleaseFile
+ *
+ * Flush the current profile to disk and remove it from the cache.
+ ***********************************************************************/
+static void PROFILE_ReleaseFile(void)
+{
+  PROFILE_FlushFile();
+  PROFILE_Free(CurProfile->section);
+//memfree(CurProfile->dos_name);
+//memfree(CurProfile->unix_name);
+  memfree(CurProfile->filename);
+  CurProfile->changed   = FALSE;
+  CurProfile->section   = NULL;
+//CurProfile->dos_name  = NULL;
+//CurProfile->unix_name = NULL;
+  CurProfile->filename  = NULL;
+  CurProfile->mtime     = 0;
+}  // end of PROFILE_ReleaseFile
+
+
+/***********************************************************************
+ *           PROFILE_Open
+ *
+ * Open a profile file, checking the cached file first.
+ ***********************************************************************/
+static BOOL PROFILE_Open(LPCSTR filename)
+{
+//char        buffer[MAX_PATHNAME_LEN];
+//char       *p;
+  FILE       *file = NULL;
+  int         i, j;
+  struct stat buf;
+  PROFILE    *tempProfile;
+  
+  if (trace(2))
+    htrc("PROFILE_Open: CurProfile=%p N=%d\n", CurProfile, N_CACHED_PROFILES);
+
+  /* First time around */
+  if (!CurProfile)
+    for (i = 0; i < N_CACHED_PROFILES; i++) {
+      MRUProfile[i] = (PROFILE*)malloc(sizeof(PROFILE));
+      
+      if (MRUProfile[i] == NULL)
+        break;
+        
+      MRUProfile[i]->changed=FALSE;
+      MRUProfile[i]->section=NULL;
+//    MRUProfile[i]->dos_name=NULL;
+//    MRUProfile[i]->unix_name=NULL;
+      MRUProfile[i]->filename=NULL;
+      MRUProfile[i]->mtime=0;
+      } // endfor i
+
+  /* Check for a match */
+  for (i = 0; i < N_CACHED_PROFILES; i++) {
+    if (trace(2))
+      htrc("MRU=%s i=%d\n", SVP(MRUProfile[i]->filename), i);
+      
+    if (MRUProfile[i]->filename && !strcmp(filename, MRUProfile[i]->filename)) {
+      if (i) {
+        PROFILE_FlushFile();
+        tempProfile = MRUProfile[i];
+          
+        for (j = i; j > 0; j--)
+          MRUProfile[j] = MRUProfile[j-1];
+          
+        CurProfile=tempProfile;
+        } // endif i
+        
+      if (!stat(CurProfile->filename, &buf) && CurProfile->mtime == buf.st_mtime) {
+        if (trace(2))
+          htrc("(%s): already opened (mru=%d)\n", filename, i);
+          
+      } else {
+        if (trace(2))
+          htrc("(%s): already opened, needs refreshing (mru=%d)\n",  filename, i);
+
+      } // endif stat
+      
+      return TRUE;
+      } // endif filename
+      
+    } // endfor i
+
+  /* Flush the old current profile */
+  PROFILE_FlushFile();
+
+  /* Make the oldest profile the current one only in order to get rid of it */
+  if (i == N_CACHED_PROFILES) {
+    tempProfile = MRUProfile[N_CACHED_PROFILES-1];
+    
+    for(i = N_CACHED_PROFILES-1; i > 0; i--)
+      MRUProfile[i] = MRUProfile[i-1];
+        
+    CurProfile = tempProfile;
+    } // endif i
+    
+  if (CurProfile->filename)
+    PROFILE_ReleaseFile();
+
+  /* OK, now that CurProfile is definitely free we assign it our new file */
+//  newdos_name = HeapAlloc( GetProcessHeap(), 0, strlen(full_name.short_name)+1 );
+//  strcpy( newdos_name, full_name.short_name );
+
+//  newdos_name = malloc(strlen(filename)+1);
+//  strcpy(newdos_name, filename);
+
+//  CurProfile->dos_name = newdos_name;
+  CurProfile->filename = (char*)malloc(strlen(filename) + 1);
+  strcpy(CurProfile->filename, filename);
+
+  /* Try to open the profile file, first in $HOME/.wine */
+
+  /* FIXME: this will need a more general solution */
+//  strcpy( buffer, get_config_dir() );
+//  p = buffer + strlen(buffer);
+//  *p++ = '/';
+//  strcpy( p, strrchr( newdos_name, '\\' ) + 1 );
+//  p = buffer;
+//  strcpy(p, filename);
+//  _strlwr(p);
+  
+  if (trace(2))
+    htrc("Opening %s\n", filename);
+    
+  if ((file = fopen(filename, "r"))) {
+    if (trace(2))
+      htrc("(%s): found it\n", filename);
+
+//    CurProfile->unix_name = malloc(strlen(buffer)+1);
+//    strcpy(CurProfile->unix_name, buffer);
+    } /* endif file */
+
+  if (file) {
+    CurProfile->section = PROFILE_Load(file);
+    fclose(file);
+    
+    if (!stat(CurProfile->filename, &buf))
+      CurProfile->mtime = buf.st_mtime;
+      
+  } else {
+    /* Does not exist yet, we will create it in PROFILE_FlushFile */
+    fprintf(stderr, "profile file %s not found\n", filename);
+  } /* endif file */
+
+  return TRUE;
+}
+
+
+/***********************************************************************
+ *           PROFILE_Close
+ *
+ * Flush the named profile to disk and remove it from the cache.
+ ***********************************************************************/
+void PROFILE_Close(LPCSTR filename)
+{
+  int         i;
+  BOOL        close = FALSE;
+  struct stat buf;
+  PROFILE    *tempProfile;
+  
+  if (trace(2))
+    htrc("PROFILE_Close: CurProfile=%p N=%d\n", CurProfile, N_CACHED_PROFILES);
+
+  /* Check for a match */
+  for (i = 0; i < N_CACHED_PROFILES; i++) {
+    if (trace(2))
+      htrc("MRU=%s i=%d\n", SVP(MRUProfile[i]->filename), i);
+      
+    if (MRUProfile[i]->filename && !strcmp(filename, MRUProfile[i]->filename)) {
+      if (i) {
+        /* Make the profile to close current */
+        tempProfile = MRUProfile[i];
+        MRUProfile[i] = MRUProfile[0];
+        MRUProfile[0] = tempProfile;
+        CurProfile=tempProfile;
+        } // endif i
+      
+      if (trace(2)) {
+        if (!stat(CurProfile->filename, &buf) && CurProfile->mtime == buf.st_mtime)
+          htrc("(%s): already opened (mru=%d)\n", filename, i);
+        else
+          htrc("(%s): already opened, needs refreshing (mru=%d)\n",  filename, i);
+
+        } // endif trace
+      
+      close = TRUE;
+      break;
+      } // endif filename
+      
+    } // endfor i
+
+  if (close)
+    PROFILE_ReleaseFile();
+
+}  // end of PROFILE_Close
+
+
+/***********************************************************************
+ *           PROFILE_End
+ *
+ * Terminate and release the cache.
+ ***********************************************************************/
+void PROFILE_End(void)
+{
+  int i;
+
+  if (trace(3))
+    htrc("PROFILE_End: CurProfile=%p N=%d\n", CurProfile, N_CACHED_PROFILES);
+
+	if (!CurProfile)						   //	Sergey Vojtovich
+		return;
+
+  /* Close all opened files and free the cache structure */
+  for (i = 0; i < N_CACHED_PROFILES; i++) {
+    if (trace(3))
+      htrc("MRU=%s i=%d\n", SVP(MRUProfile[i]->filename), i);
+
+//  CurProfile = MRUProfile[i];			Sergey Vojtovich
+//  PROFILE_ReleaseFile();					see MDEV-9997
+    free(MRUProfile[i]);
+    } // endfor i
+
+}  // end of PROFILE_End
+
+
+/***********************************************************************
+ *           PROFILE_DeleteSection
+ *
+ * Delete a section from a profile tree.
+ ***********************************************************************/
+static BOOL PROFILE_DeleteSection(PROFILESECTION* *section, LPCSTR name)
+{
+  while (*section) {
+    if ((*section)->name[0] && !stricmp((*section)->name, name)) {
+      PROFILESECTION *to_del = *section;
+
+      *section = to_del->next;
+      to_del->next = NULL;
+      PROFILE_Free(to_del);
+      return TRUE;
+      } // endif section
+
+    section = &(*section)->next;
+    } // endwhile section
+
+  return FALSE;
+}  // end of PROFILE_DeleteSection
+
+
+/***********************************************************************
+ *           PROFILE_DeleteKey
+ *
+ * Delete a key from a profile tree.
+ ***********************************************************************/
+static BOOL PROFILE_DeleteKey(PROFILESECTION* *section,
+                              LPCSTR section_name, LPCSTR key_name)
+{
+  while (*section) {
+    if ((*section)->name[0] && !stricmp((*section)->name, section_name)) {
+      PROFILEKEY* *key = &(*section)->key;
+
+      while (*key) {
+        if (!stricmp((*key)->name, key_name))  {
+          PROFILEKEY *to_del = *key;
+
+          *key = to_del->next;
+          memfree(to_del->value);
+          free(to_del);
+          return TRUE;
+          } // endif name
+
+        key = &(*key)->next;
+        } // endwhile *key
+
+      } // endif section->name
+
+    section = &(*section)->next;
+    } // endwhile *section
+
+  return FALSE;
+}  // end of PROFILE_DeleteKey
+
+
+/***********************************************************************
+ *           PROFILE_DeleteAllKeys
+ *
+ * Delete all keys from a profile tree.
+ ***********************************************************************/
+static void PROFILE_DeleteAllKeys(LPCSTR section_name)
+{
+  PROFILESECTION* *section= &CurProfile->section;
+
+  while (*section) {
+    if ((*section)->name[0] && !stricmp((*section)->name, section_name)) {
+      PROFILEKEY* *key = &(*section)->key;
+
+      while (*key) {
+        PROFILEKEY *to_del = *key;
+
+        *key = to_del->next;
+        memfree(to_del->value);
+        free(to_del);
+        CurProfile->changed = TRUE;
+        } // endwhile *key
+
+      } // endif section->name
+
+    section = &(*section)->next;
+    }  // endwhile *section
+
+} // end of PROFILE_DeleteAllKeys
+
+
+/***********************************************************************
+ *           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, 
+                                BOOL create, BOOL create_always)
+{
+  const char *p;
+  int seclen, keylen;
+
+  while (PROFILE_isspace(*section_name))
+    section_name++;
+
+  p = section_name + strlen(section_name) - 1;
+
+  while ((p > section_name) && PROFILE_isspace(*p))
+    p--;
+
+  seclen = p - section_name + 1;
+
+  while (PROFILE_isspace(*key_name))
+    key_name++;
+
+  p = key_name + strlen(key_name) - 1;
+
+  while ((p > key_name) && PROFILE_isspace(*p))
+    p--;
+
+  keylen = p - key_name + 1;
+
+  while (*section) {
+    if (((*section)->name[0])
+         && (!(_strnicmp((*section)->name, section_name, seclen )))
+         && (((*section)->name)[seclen] == '\0')) {
+      PROFILEKEY* *key = &(*section)->key;
+
+      while (*key) {
+        /* If create_always is FALSE then we check if the keyname already exists.
+         * Otherwise we add it regardless of its existence, to allow
+         * keys to be added more then once in some cases.
+         */
+        if (!create_always) {
+          if ((!(_strnicmp( (*key)->name, key_name, keylen )))
+               && (((*key)->name)[keylen] == '\0'))
+            return *key;
+
+          }  // endif !create_always
+
+        key = &(*key)->next;
+        } // endwhile *key
+
+      if (!create)
+        return NULL;
+
+      if (!(*key = (PROFILEKEY*)malloc(sizeof(PROFILEKEY) + strlen(key_name))))
+        return NULL;
+
+      strcpy((*key)->name, key_name);
+      (*key)->value = NULL;
+      (*key)->next  = NULL;
+      return *key;
+      } // endifsection->name
+
+    section = &(*section)->next;
+    } // endwhile *section
+
+  if (!create)
+    return NULL;
+
+  *section = (PROFILESECTION*)malloc(sizeof(PROFILESECTION) + strlen(section_name));
+
+  if (*section == NULL)
+    return NULL;
+
+  strcpy((*section)->name, section_name);
+  (*section)->next = NULL;
+
+  if (!((*section)->key = (tagPROFILEKEY*)malloc(sizeof(PROFILEKEY) + strlen(key_name)))) {
+    free(*section);
+    return NULL;
+    }  // endif malloc
+
+  strcpy((*section)->key->name, key_name);
+  (*section)->key->value = NULL;
+  (*section)->key->next  = NULL;
+  return (*section)->key;
+}  // end of PROFILE_Find
+
+
+/***********************************************************************
+ *           PROFILE_GetSection
+ *
+ * Returns all keys of a section.
+ * If return_values is TRUE, also include the corresponding values.
+ ***********************************************************************/
+static int PROFILE_GetSection(PROFILESECTION *section, LPCSTR section_name,
+                              LPSTR buffer, uint len,
+                              BOOL handle_env, BOOL return_values)
+{
+  PROFILEKEY *key;
+
+  if(!buffer) 
+    return 0;
+
+  while (section) {
+    if (section->name[0] && !stricmp(section->name, section_name)) {
+      uint oldlen = len;
+
+      for (key = section->key; key; key = key->next) {
+        if (len <= 2)
+          break;
+
+        if (!*key->name)
+          continue;  /* Skip empty lines */
+
+        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;
+
+        if (len < 2)
+          break;
+
+        if (return_values && key->value) {
+          buffer[-1] = '=';
+          PROFILE_CopyEntry(buffer, key->value, len - 1, handle_env);
+          len -= strlen(buffer) + 1;
+          buffer += strlen(buffer) + 1;
+          } // endif return_values
+
+        } // endfor key
+
+      *buffer = '\0';
+
+      if (len <= 1) {
+        /*If either lpszSection or lpszKey is NULL and the supplied
+          destination buffer is too small to hold all the strings,
+          the last string is truncated and followed by two null characters.
+          In this case, the return value is equal to cchReturnBuffer
+          minus two. */
+        buffer[-1] = '\0';
+        return oldlen - 2;
+        } // endif len
+
+      return oldlen - len;
+      } // endif section->name
+
+    section = section->next;
+    } // endwhile section
+
+  buffer[0] = buffer[1] = '\0';
+  return 0;
+}  // end of PROFILE_GetSection
+
+
+/* See GetPrivateProfileSectionNamesA for documentation */
+static int PROFILE_GetSectionNames(LPSTR buffer, uint len)
+{
+  LPSTR           buf;
+  uint            f,l;
+  PROFILESECTION *section;
+
+  if (trace(2))
+    htrc("GetSectionNames: buffer=%p len=%u\n", buffer, len);
+
+  if (!buffer || !len)
+    return 0;
+
+  if (len == 1) {
+    *buffer='\0';
+    return 0;
+    } // endif len
+
+  f = len - 1;
+  buf = buffer;
+  section = CurProfile->section;
+
+  if (trace(2))
+    htrc("GetSectionNames: section=%p\n", section);
+
+  while (section != NULL) {
+    if (trace(2))
+      htrc("section=%s\n", section->name);
+
+    if (section->name[0]) {
+      l = strlen(section->name) + 1;
+
+      if (trace(2))
+        htrc("l=%u f=%u\n", l, f);
+
+      if (l > f) {
+        if (f > 0) {
+          strncpy(buf, section->name, f-1);
+          buf += f-1;
+          *buf++='\0';
+          } // endif f
+
+        *buf = '\0';
+        return len - 2;
+        } // endif l
+
+      strcpy(buf, section->name);
+      buf += l;
+      f -= l;
+      } // endif section->name
+
+    section = section->next;
+    } // endwhile section
+
+  *buf='\0';
+  return buf-buffer;
+}  // end of  PROFILE_GetSectionNames
+
+
+/***********************************************************************
+ *           PROFILE_GetString
+ *
+ * Get a profile string.
+ *
+ * Tests with GetPrivateProfileString16, W95a,
+ * with filled buffer ("****...") and section "set1" and key_name "1" valid:
+ * section      key_name        def_val         res     buffer
+ * "set1"       "1"             "x"             43      [data]
+ * "set1"       "1   "          "x"             43      [data]          (!)
+ * "set1"       "  1  "'        "x"             43      [data]          (!)
+ * "set1"       ""              "x"             1       "x"
+ * "set1"       ""              "x   "          1       "x"             (!)
+ * "set1"       ""              "  x   "        3       "  x"           (!)
+ * "set1"       NULL            "x"             6       "1\02\03\0\0"
+ * "set1"       ""              "x"             1       "x"
+ * NULL         "1"             "x"             0       ""              (!)
+ * ""           "1"             "x"             1       "x"
+ * NULL         NULL            ""              0       ""
+ *
+ *************************************************************************/
+static int PROFILE_GetString(LPCSTR section, LPCSTR key_name,
+                             LPCSTR def_val, LPSTR buffer, uint len)
+{
+  PROFILEKEY *key = NULL;
+
+  if(!buffer)
+    return 0;
+
+  if (!def_val)
+    def_val = "";
+
+  if (key_name && key_name[0]) {
+    key = PROFILE_Find(&CurProfile->section, section, key_name, FALSE, FALSE);
+    PROFILE_CopyEntry(buffer, (key && key->value) ? key->value : def_val, len, FALSE);
+    
+    if (trace(2))
+      htrc("('%s','%s','%s'): returning '%s'\n", 
+            section, key_name, def_val, buffer );
+
+    return strlen(buffer);
+    } // endif key_name
+
+  if (key_name && !(key_name[0]))
+    /* Win95 returns 0 on keyname "". Tested with Likse32 bon 000227 */
+    return 0;
+
+  if (section && section[0])
+    return PROFILE_GetSection(CurProfile->section, section, buffer, len,
+                              FALSE, FALSE);
+  buffer[0] = '\0';
+  return 0;
+}  // end of PROFILE_GetString
+
+
+/***********************************************************************
+ *           PROFILE_SetString
+ *
+ * Set a profile string.
+ ***********************************************************************/
+static BOOL PROFILE_SetString(LPCSTR section_name, LPCSTR key_name,
+                              LPCSTR value, BOOL create_always)
+{
+  if (!key_name) {       /* Delete a whole section */
+    if (trace(2))
+      htrc("Deleting('%s')\n", section_name);
+
+    CurProfile->changed |= PROFILE_DeleteSection(&CurProfile->section,
+                                                 section_name);
+    return TRUE;         /* Even if PROFILE_DeleteSection() has failed,
+                            this is not an error on application's level.*/
+  } else if (!value) {   /* Delete a key */
+    if (trace(2))
+      htrc("Deleting('%s','%s')\n", section_name, key_name);
+
+    CurProfile->changed |= PROFILE_DeleteKey(&CurProfile->section,
+                                             section_name, key_name);
+    return TRUE;         /* same error handling as above */
+  } else {               /* Set the key value */
+    PROFILEKEY *key = PROFILE_Find(&CurProfile->section, section_name,
+                                    key_name, TRUE, create_always);
+    if (trace(2))
+      htrc("Setting('%s','%s','%s')\n", section_name, key_name, value);
+
+    if (!key)
+      return FALSE;
+
+    if (key->value) {
+      /* strip the leading spaces. We can safely strip \n\r and
+       * friends too, they should not happen here anyway. */
+      while (PROFILE_isspace(*value))
+        value++;
+
+      if (!strcmp(key->value, value)) {
+        if (trace(2))
+          htrc("  no change needed\n" );
+
+        return TRUE;     /* No change needed */
+        }  // endif value
+
+      if (trace(2))
+        htrc("  replacing '%s'\n", key->value);
+
+      free(key->value);
+    }  else if (trace(2))
+      htrc("  creating key\n" );
+
+    key->value = (char*)malloc(strlen(value) + 1);
+    strcpy(key->value, value);
+    CurProfile->changed = TRUE;
+  } // endelse
+
+  return TRUE;
+}  // end of PROFILE_SetString
+
+
+/***********************************************************************
+ *           PROFILE_GetStringItem
+ *
+ *  Convenience function that turns a string 'xxx, yyy, zzz' into
+ *  the 'xxx\0 yyy, zzz' and returns a pointer to the 'yyy, zzz'.
+ ***********************************************************************/
+#if 0
+char *PROFILE_GetStringItem(char* start)
+{
+  char *lpchX, *lpch;
+
+  for (lpchX = start, lpch = NULL; *lpchX != '\0'; lpchX++) {
+    if (*lpchX == ',') {
+      if (lpch)
+        *lpch = '\0';
+      else
+        *lpchX = '\0';
+
+      while(*(++lpchX))
+        if (!PROFILE_isspace(*lpchX))
+          return lpchX;
+
+    } else if (PROFILE_isspace(*lpchX) && !lpch) {
+      lpch = lpchX;
+    } else
+      lpch = NULL;
+
+    } // endfor lpchX
+
+  if (lpch)
+    *lpch = '\0';
+
+  return NULL;
+}  // end of PROFILE_GetStringItem
+#endif
+
+/**********************************************************************
+ * if allow_section_name_copy is TRUE, allow the copying :
+ *   - of Section names if 'section' is NULL
+ *   - of Keys in a Section if 'entry' is NULL
+ * (see MSDN doc for GetPrivateProfileString)
+ **********************************************************************/
+static int PROFILE_GetPrivateProfileString(LPCSTR section, LPCSTR entry,
+                                           LPCSTR def_val, LPSTR buffer,
+                                           uint len, LPCSTR filename,
+                                           BOOL allow_section_name_copy)
+{
+  int   ret;
+  LPSTR pDefVal = NULL;
+
+  if (!filename)
+    filename = "win.ini";
+
+  /* strip any trailing ' ' of def_val. */
+  if (def_val) {
+    LPSTR p = (LPSTR)&def_val[strlen(def_val)]; // even "" works !
+
+    while (p > def_val)
+      if ((*(--p)) != ' ')
+        break;
+
+    if (*p == ' ') {        /* ouch, contained trailing ' ' */
+      int len = p - (LPSTR)def_val;
+
+      pDefVal = (LPSTR)malloc(len + 1);
+      strncpy(pDefVal, def_val, len);
+      pDefVal[len] = '\0';
+      } // endif *p
+
+    } // endif def_val
+
+  if (!pDefVal)
+    pDefVal = (LPSTR)def_val;
+
+  EnterCriticalSection(&PROFILE_CritSect);
+
+  if (PROFILE_Open(filename)) {
+    if ((allow_section_name_copy) && (section == NULL))
+      ret = PROFILE_GetSectionNames(buffer, len);
+    else
+      /* PROFILE_GetString already handles the 'entry == NULL' case */
+      ret = PROFILE_GetString(section, entry, pDefVal, buffer, len);
+
+  } else {
+    strncpy(buffer, pDefVal, len);
+    ret = strlen(buffer);
+  }  // endif Open
+
+  LeaveCriticalSection(&PROFILE_CritSect);
+
+  if (pDefVal != def_val) /* allocated */
+    memfree(pDefVal);
+
+  return ret;
+}  // end of PROFILE_GetPrivateProfileString
+
+/********************** API functions **********************************/
+
+/***********************************************************************
+ *           GetPrivateProfileStringA   (KERNEL32.@)
+ ***********************************************************************/
+int GetPrivateProfileString(LPCSTR section, LPCSTR entry, LPCSTR def_val,
+                            LPSTR buffer, DWORD len, LPCSTR filename)
+{
+  return PROFILE_GetPrivateProfileString(section, entry, def_val,
+                                         buffer, len, filename, TRUE);
+} // end of GetPrivateProfileString
+
+
+/***********************************************************************
+ *           GetPrivateProfileIntA   (KERNEL32.@)
+ ***********************************************************************/
+uint GetPrivateProfileInt(LPCSTR section, LPCSTR entry,
+                          int def_val, LPCSTR filename)
+{
+  char buffer[20];
+  int  result;
+
+  if (!PROFILE_GetPrivateProfileString(section, entry, "", buffer,
+                                       sizeof(buffer), filename, FALSE))
+    return def_val;
+
+  /* FIXME: if entry can be found but it's empty, then Win16 is
+   * supposed to return 0 instead of def_val ! Difficult/problematic
+   * to implement (every other failure also returns zero buffer),
+   * thus wait until testing framework avail for making sure nothing
+   * else gets broken that way. */
+  if (!buffer[0])
+    return (uint)def_val;
+
+  /* Don't use strtol() here !
+   * (returns LONG_MAX/MIN on overflow instead of "proper" overflow)
+   YES, scan for unsigned format ! (otherwise compatibility error) */
+  if (!sscanf(buffer, "%u", &result))
+    return 0;
+
+  return (uint)result;
+}  // end of GetPrivateProfileInt
+
+
+/***********************************************************************
+ *           GetPrivateProfileSectionA   (KERNEL32.@)
+ ***********************************************************************/
+int GetPrivateProfileSection(LPCSTR section, LPSTR buffer,
+                             DWORD len, LPCSTR filename)
+{
+  int ret = 0;
+
+  EnterCriticalSection( &PROFILE_CritSect );
+
+  if (PROFILE_Open(filename))
+    ret = PROFILE_GetSection(CurProfile->section, section, buffer, len,
+                             FALSE, TRUE);
+
+  LeaveCriticalSection( &PROFILE_CritSect );
+  return ret;
+}  // end of GetPrivateProfileSection
+
+
+/***********************************************************************
+ *           WritePrivateProfileStringA   (KERNEL32.@)
+ ***********************************************************************/
+BOOL WritePrivateProfileString(LPCSTR section, LPCSTR entry,
+                               LPCSTR string, LPCSTR filename)
+{
+  BOOL ret = FALSE;
+
+  EnterCriticalSection( &PROFILE_CritSect );
+
+  if (PROFILE_Open(filename)) {
+    if (!section && !entry && !string) /* documented "file flush" case */
+      PROFILE_ReleaseFile();  /* always return FALSE in this case */
+    else {
+      if (!section) {
+        //FIXME("(NULL?,%s,%s,%s)? \n",entry,string,filename);
+      } else {
+        ret = PROFILE_SetString(section, entry, string, FALSE);
+
+        if (ret)
+          ret = PROFILE_FlushFile();
+
+      } // endif section
+
+    } // endif section || entry|| string
+
+    } // endif Open
+
+  LeaveCriticalSection( &PROFILE_CritSect );
+  return ret;
+}  // end of WritePrivateProfileString
+
+
+/***********************************************************************
+ *           WritePrivateProfileSectionA   (KERNEL32.@)
+ ***********************************************************************/
+BOOL WritePrivateProfileSection(LPCSTR section,
+                                LPCSTR string, LPCSTR filename )
+{
+  BOOL  ret = FALSE;
+  LPSTR p ;
+
+  EnterCriticalSection(&PROFILE_CritSect);
+
+  if (PROFILE_Open(filename)) {
+    if (!section && !string)
+      PROFILE_ReleaseFile();  /* always return FALSE in this case */
+    else if (!string) {       /* delete the named section*/
+      ret = PROFILE_SetString(section, NULL, NULL, FALSE);
+
+      if (ret)
+        ret = PROFILE_FlushFile();
+    }  else {
+      PROFILE_DeleteAllKeys(section);
+      ret = TRUE;
+
+      while (*string) {
+        LPSTR buf = (LPSTR)malloc(strlen(string) + 1);
+        strcpy(buf, string);
+
+        if ((p = strchr(buf, '='))) {
+          *p='\0';
+          ret = PROFILE_SetString(section, buf, p+1, TRUE);
+          } // endif p
+
+        free(buf);
+        string += strlen(string) + 1;
+
+        if (ret)
+          ret = PROFILE_FlushFile();
+
+        } // endwhile *string
+
+    }  // endelse
+
+    }  // endif Open
+
+  LeaveCriticalSection(&PROFILE_CritSect);
+  return ret;
+}  // end of WritePrivateProfileSection
+
+
+/***********************************************************************
+ *           GetPrivateProfileSectionNamesA  (KERNEL32.@)
+ *
+ * Returns the section names contained in the specified file.
+ * FIXME: Where do we find this file when the path is relative?
+ * The section names are returned as a list of strings with an extra
+ * '\0' to mark the end of the list. Except for that the behavior
+ * depends on the Windows version.
+ *
+ * Win95:
+ * - if the buffer is 0 or 1 character long then it is as if it was of
+ *   infinite length.
+ * - otherwise, if the buffer is to small only the section names that fit
+ *   are returned.
+ * - note that this means if the buffer was to small to return even just
+ *   the first section name then a single '\0' will be returned.
+ * - the return value is the number of characters written in the buffer,
+ *   except if the buffer was too smal in which case len-2 is returned
+ *
+ * Win2000:
+ * - if the buffer is 0, 1 or 2 characters long then it is filled with
+ *   '\0' and the return value is 0
+ * - otherwise if the buffer is too small then the first section name that
+ *   does not fit is truncated so that the string list can be terminated
+ *   correctly (double '\0')
+ * - the return value is the number of characters written in the buffer
+ *   except for the trailing '\0'. If the buffer is too small, then the
+ *   return value is len-2
+ * - Win2000 has a bug that triggers when the section names and the
+ *   trailing '\0' fit exactly in the buffer. In that case the trailing
+ *   '\0' is missing.
+ *
+ * Wine implements the observed Win2000 behavior (except for the bug).
+ *
+ * Note that when the buffer is big enough then the return value may be any
+ * value between 1 and len-1 (or len in Win95), including len-2.
+ */
+#ifdef TEST_MODULE
+static DWORD
+GetPrivateProfileSectionNames(LPSTR buffer, DWORD size,  LPCSTR filename)
+{
+  DWORD ret = 0;
+  
+  if (trace(2))
+    htrc("GPPSN: filename=%s\n", filename);
+
+  EnterCriticalSection(&PROFILE_CritSect);
+
+  if (PROFILE_Open(filename))
+    ret = PROFILE_GetSectionNames(buffer, size);
+
+  LeaveCriticalSection(&PROFILE_CritSect);
+  return ret;
+}  // end of GetPrivateProfileSectionNames
+
+
+/************************************************************************
+ * Program to test the above
+ ************************************************************************/
+int main(int argc, char**argv) {
+  char  buff[128];
+  char *p, *inifile = "D:\\Plug\\Data\\contact.ini";
+  DWORD n;
+
+  n = GetPrivateProfileSectionNames(buff, 128, inifile);
+  printf("Sections: n=%d\n", n);
+
+  for (p = buff; *p; p += (strlen(p) + 1))
+    printf("section=[%s]\n", p);
+
+  GetPrivateProfileString("BER", "name", "?", buff, 128, inifile);
+  printf("[BER](name) = %s\n", buff);
+
+  WritePrivateProfileString("FOO", "city", NULL, inifile);
+  GetPrivateProfileString("FOO", "city", "?", buff, 128, inifile);
+  printf("[FOO](city) = %s\n", buff);
+
+  printf("FOO city: "); 
+  fgets(buff, sizeof(buff), stdin);
+  if (buff[strlen(buff) - 1] == '\n') 
+      buff[strlen(buff) - 1] = '\0'; 
+  WritePrivateProfileString("FOO", "city", buff, inifile);
+  GetPrivateProfileString("FOO", "city", "???", buff, 128, inifile);
+  printf("After write, [FOO](City) = %s\n", buff);
+
+  printf("New city: "); 
+  fgets(buff, sizeof(buff), stdin);
+  if (buff[strlen(buff) - 1] == '\n') 
+      buff[strlen(buff) - 1] = '\0'; 
+  WritePrivateProfileString("FOO", "city", buff, inifile);
+  GetPrivateProfileString("FOO", "city", "???", buff, 128, inifile);
+  printf("After update, [FOO](City) = %s\n", buff);
+
+  printf("FOO name: "); 
+  fgets(buff, sizeof(buff), stdin);
+  if (buff[strlen(buff) - 1] == '\n') 
+      buff[strlen(buff) - 1] = '\0'; 
+  WritePrivateProfileString("FOO", "name", buff, inifile);
+  GetPrivateProfileString("FOO", "name", "X", buff, 128, inifile);
+  printf("[FOO](name) = %s\n", buff);
+}  // end of main
+#endif // TEST_MODULE