files/profile.c

   1 /*
   2  * Profile functions
   3  *
   4  * Copyright 1993 Miguel de Icaza
   5  * Copyright 1996 Alexandre Julliard
   6  */
   7
   8 #include <ctype.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <sys/stat.h>
  12 #include <sys/types.h>
  13 #include <pwd.h>
  14 #include <unistd.h>
  15
  16 #include "winbase.h"
  17 #include "winerror.h"
  18 #include "wine/winbase16.h"
  19 #include "winuser.h"
  20 #include "winnls.h"
  21 #include "file.h"
  22 #include "heap.h"
  23 #include "debugtools.h"
  24 #include "xmalloc.h"
  25 #include "options.h"
  26
  27 DEFAULT_DEBUG_CHANNEL(profile)
  28
  29 typedef struct tagPROFILEKEY
  30 {
  31     char                  *name;
  32     char                  *value;
  33     struct tagPROFILEKEY  *next;
  34 } PROFILEKEY;
  35
  36 typedef struct tagPROFILESECTION
  37 {
  38     char                       *name;
  39     struct tagPROFILEKEY       *key;
  40     struct tagPROFILESECTION   *next;
  41 } PROFILESECTION;
  42
  43
  44 typedef struct
  45 {
  46     BOOL             changed;
  47     PROFILESECTION  *section;
  48     char            *dos_name;
  49     char            *unix_name;
  50     char            *filename;
  51     time_t           mtime;
  52 } PROFILE;
  53
  54
  55 #define N_CACHED_PROFILES 10
  56
  57 /* Cached profile files */
  58 static PROFILE *MRUProfile[N_CACHED_PROFILES]={NULL};
  59
  60 #define CurProfile (MRUProfile[0])
  61
  62 /* wine.ini profile content */
  63 static PROFILESECTION *PROFILE_WineProfile;
  64
  65 #define PROFILE_MAX_LINE_LEN   1024
  66
  67 /* Wine profile name in $HOME directory; must begin with slash */
  68 static const char PROFILE_WineIniName[] = "/.winerc";
  69
  70 /* Wine profile: the profile file being used */
  71 static char PROFILE_WineIniUsed[MAX_PATHNAME_LEN] = "";
  72
  73 /* Check for comments in profile */
  74 #define IS_ENTRY_COMMENT(str)  ((str)[0] == ';')
  75
  76 #define WINE_INI_GLOBAL ETCDIR "/wine.conf"
  77 #define WINE_CONFIG_DIR "/.wine"   /* config dir inside $HOME */
  78
  79 static LPCWSTR wininiW = NULL;
  80
  81 static CRITICAL_SECTION PROFILE_CritSect;
  82
  83
  84 /***********************************************************************
  85  *           PROFILE_GetConfigDir
  86  *
  87  * Return the name of the configuration directory ($HOME/.wine)
  88  */
  89 const char *PROFILE_GetConfigDir(void)
  90 {
  91     static char *confdir;
  92     if (!confdir)
  93     {
  94         const char *home = getenv( "HOME" );
  95         if (!home)
  96         {
  97             struct passwd *pwd = getpwuid( getuid() );
  98             if (!pwd)
  99             {
 100                 fprintf( stderr, "wine: could not find your home directory\n" );
 101                 exit(1);
 102             }
 103             home = pwd->pw_dir;
 104         }
 105         confdir = xmalloc( strlen(home) + strlen(WINE_CONFIG_DIR) + 1 );
 106         strcpy( confdir, home );
 107         strcat( confdir, WINE_CONFIG_DIR );
 108         mkdir( confdir, 0755 );  /* create it just in case */
 109     }
 110     return confdir;
 111 }
 112
 113
 114 /***********************************************************************
 115  *           PROFILE_CopyEntry
 116  *
 117  * Copy the content of an entry into a buffer, removing quotes, and possibly
 118  * translating environment variables.
 119  */
 120 static void PROFILE_CopyEntry( char *buffer, const char *value, int len,
 121                                int handle_env )
 122 {
 123     char quote = '\0';
 124     const char *p;
 125
 126     if ((*value == '\'') || (*value == '\"'))
 127     {
 128         if (value[1] && (value[strlen(value)-1] == *value)) quote = *value++;
 129     }
 130
 131     if (!handle_env)
 132     {
 133         lstrcpynA( buffer, value, len );
 134         if (quote && (len >= strlen(value))) buffer[strlen(buffer)-1] = '\0';
 135         return;
 136     }
 137
 138     for (p = value; (*p && (len > 1)); *buffer++ = *p++, len-- )
 139     {
 140         if ((*p == '$') && (p[1] == '{'))
 141         {
 142             char env_val[1024];
 143             const char *env_p;
 144             const char *p2 = strchr( p, '}' );
 145             if (!p2) continue;  /* ignore it */
 146             lstrcpynA(env_val, p + 2, MIN( sizeof(env_val), (int)(p2-p)-1 ));
 147             if ((env_p = getenv( env_val )) != NULL)
 148             {
 149                 lstrcpynA( buffer, env_p, len );
 150                 buffer += strlen( buffer );
 151                 len -= strlen( buffer );
 152             }
 153             p = p2 + 1;
 154         }
 155     }
 156     if (quote && (len > 1)) buffer--;
 157     *buffer = '\0';
 158 }
 159
 160
 161 /***********************************************************************
 162  *           PROFILE_Save
 163  *
 164  * Save a profile tree to a file.
 165  */
 166 static void PROFILE_Save( FILE *file, PROFILESECTION *section )
 167 {
 168     PROFILEKEY *key;
 169
 170     for ( ; section; section = section->next)
 171     {
 172         if (section->name) fprintf( file, "\r\n[%s]\r\n", section->name );
 173         for (key = section->key; key; key = key->next)
 174         {
 175             fprintf( file, "%s", key->name );
 176             if (key->value) fprintf( file, "=%s", key->value );
 177             fprintf( file, "\r\n" );
 178         }
 179     }
 180 }
 181
 182
 183 /***********************************************************************
 184  *           PROFILE_Free
 185  *
 186  * Free a profile tree.
 187  */
 188 static void PROFILE_Free( PROFILESECTION *section )
 189 {
 190     PROFILESECTION *next_section;
 191     PROFILEKEY *key, *next_key;
 192
 193     for ( ; section; section = next_section)
 194     {
 195         if (section->name) HeapFree( SystemHeap, 0, section->name );
 196         for (key = section->key; key; key = next_key)
 197         {
 198             next_key = key->next;
 199             if (key->name) HeapFree( SystemHeap, 0, key->name );
 200             if (key->value) HeapFree( SystemHeap, 0, key->value );
 201             HeapFree( SystemHeap, 0, key );
 202         }
 203         next_section = section->next;
 204         HeapFree( SystemHeap, 0, section );
 205     }
 206 }
 207
 208 static int
 209 PROFILE_isspace(char c) {
 210         if (isspace(c)) return 1;
 211         if (c=='\r' || c==0x1a) return 1;
 212         /* CR and ^Z (DOS EOF) are spaces too  (found on CD-ROMs) */
 213         return 0;
 214 }
 215
 216
 217 /***********************************************************************
 218  *           PROFILE_Load
 219  *
 220  * Load a profile tree from a file.
 221  */
 222 static PROFILESECTION *PROFILE_Load( FILE *file )
 223 {
 224     char buffer[PROFILE_MAX_LINE_LEN];
 225     char *p, *p2;
 226     int line = 0;
 227     PROFILESECTION *section, *first_section;
 228     PROFILESECTION **next_section;
 229     PROFILEKEY *key, *prev_key, **next_key;
 230
 231     first_section = HEAP_xalloc( SystemHeap, 0, sizeof(*section) );
 232     first_section->name = NULL;
 233     first_section->key  = NULL;
 234     first_section->next = NULL;
 235     next_section = &first_section->next;
 236     next_key     = &first_section->key;
 237     prev_key     = NULL;
 238
 239     while (fgets( buffer, PROFILE_MAX_LINE_LEN, file ))
 240     {
 241         line++;
 242         p = buffer;
 243         while (*p && PROFILE_isspace(*p)) p++;
 244         if (*p == '[')  /* section start */
 245         {
 246             if (!(p2 = strrchr( p, ']' )))
 247             {
 248                 WARN("Invalid section header at line %d: '%s'\n",
 249                      line, p );
 250             }
 251             else
 252             {
 253                 *p2 = '\0';
 254                 p++;
 255                 section = HEAP_xalloc( SystemHeap, 0, sizeof(*section) );
 256                 section->name = HEAP_strdupA( SystemHeap, 0, p );
 257                 section->key  = NULL;
 258                 section->next = NULL;
 259                 *next_section = section;
 260                 next_section  = &section->next;
 261                 next_key      = &section->key;
 262                 prev_key      = NULL;
 263
 264                 TRACE("New section: '%s'\n",section->name);
 265
 266                 continue;
 267             }
 268         }
 269
 270         p2=p+strlen(p) - 1;
 271         while ((p2 > p) && ((*p2 == '\n') || PROFILE_isspace(*p2))) *p2--='\0';
 272
 273         if ((p2 = strchr( p, '=' )) != NULL)
 274         {
 275             char *p3 = p2 - 1;
 276             while ((p3 > p) && PROFILE_isspace(*p3)) *p3-- = '\0';
 277             *p2++ = '\0';
 278             while (*p2 && PROFILE_isspace(*p2)) p2++;
 279         }
 280
 281         if(*p || !prev_key || *prev_key->name)
 282           {
 283            key = HEAP_xalloc( SystemHeap, 0, sizeof(*key) );
 284            key->name  = HEAP_strdupA( SystemHeap, 0, p );
 285            key->value = p2 ? HEAP_strdupA( SystemHeap, 0, p2 ) : NULL;
 286            key->next  = NULL;
 287            *next_key  = key;
 288            next_key   = &key->next;
 289            prev_key   = key;
 290
 291            TRACE("New key: name='%s', value='%s'\n",key->name,key->value?key->value:"(none)");
 292           }
 293     }
 294     return first_section;
 295 }
 296
 297
 298 /***********************************************************************
 299  *           PROFILE_DeleteSection
 300  *
 301  * Delete a section from a profile tree.
 302  */
 303 static BOOL PROFILE_DeleteSection( PROFILESECTION **section, LPCSTR name )
 304 {
 305     while (*section)
 306     {
 307         if ((*section)->name && !strcasecmp( (*section)->name, name ))
 308         {
 309             PROFILESECTION *to_del = *section;
 310             *section = to_del->next;
 311             to_del->next = NULL;
 312             PROFILE_Free( to_del );
 313             return TRUE;
 314         }
 315         section = &(*section)->next;
 316     }
 317     return FALSE;
 318 }
 319
 320
 321 /***********************************************************************
 322  *           PROFILE_DeleteKey
 323  *
 324  * Delete a key from a profile tree.
 325  */
 326 static BOOL PROFILE_DeleteKey( PROFILESECTION **section,
 327                                LPCSTR section_name, LPCSTR key_name )
 328 {
 329     while (*section)
 330     {
 331         if ((*section)->name && !strcasecmp( (*section)->name, section_name ))
 332         {
 333             PROFILEKEY **key = &(*section)->key;
 334             while (*key)
 335             {
 336                 if (!strcasecmp( (*key)->name, key_name ))
 337                 {
 338                     PROFILEKEY *to_del = *key;
 339                     *key = to_del->next;
 340                     if (to_del->name) HeapFree( SystemHeap, 0, to_del->name );
 341                     if (to_del->value) HeapFree( SystemHeap, 0, to_del->value);
 342                     HeapFree( SystemHeap, 0, to_del );
 343                     return TRUE;
 344                 }
 345                 key = &(*key)->next;
 346             }
 347         }
 348         section = &(*section)->next;
 349     }
 350     return FALSE;
 351 }
 352
 353
 354 /***********************************************************************
 355  *           PROFILE_Find
 356  *
 357  * Find a key in a profile tree, optionally creating it.
 358  */
 359 static PROFILEKEY *PROFILE_Find( PROFILESECTION **section,
 360                                  const char *section_name,
 361                                  const char *key_name, int create )
 362 {
 363     while (*section)
 364     {
 365         if ((*section)->name && !strcasecmp( (*section)->name, section_name ))
 366         {
 367             PROFILEKEY **key = &(*section)->key;
 368             while (*key)
 369             {
 370                 if (!strcasecmp( (*key)->name, key_name )) return *key;
 371                 key = &(*key)->next;
 372             }
 373             if (!create) return NULL;
 374             *key = HEAP_xalloc( SystemHeap, 0, sizeof(PROFILEKEY) );
 375             (*key)->name  = HEAP_strdupA( SystemHeap, 0, key_name );
 376             (*key)->value = NULL;
 377             (*key)->next  = NULL;
 378             return *key;
 379         }
 380         section = &(*section)->next;
 381     }
 382     if (!create) return NULL;
 383     *section = HEAP_xalloc( SystemHeap, 0, sizeof(PROFILESECTION) );
 384     (*section)->name = HEAP_strdupA( SystemHeap, 0, section_name );
 385     (*section)->next = NULL;
 386     (*section)->key  = HEAP_xalloc( SystemHeap, 0, sizeof(PROFILEKEY) );
 387     (*section)->key->name  = HEAP_strdupA( SystemHeap, 0, key_name );
 388     (*section)->key->value = NULL;
 389     (*section)->key->next  = NULL;
 390     return (*section)->key;
 391 }
 392
 393
 394 /***********************************************************************
 395  *           PROFILE_FlushFile
 396  *
 397  * Flush the current profile to disk if changed.
 398  */
 399 static BOOL PROFILE_FlushFile(void)
 400 {
 401     char *p, buffer[MAX_PATHNAME_LEN];
 402     const char *unix_name;
 403     FILE *file = NULL;
 404     struct stat buf;
 405
 406     if(!CurProfile)
 407     {
 408         WARN("No current profile!\n");
 409         return FALSE;
 410     }
 411
 412     if (!CurProfile->changed || !CurProfile->dos_name) return TRUE;
 413     if (!(unix_name = CurProfile->unix_name) || !(file = fopen(unix_name, "w")))
 414     {
 415         /* Try to create it in $HOME/.wine */
 416         /* FIXME: this will need a more general solution */
 417         strcpy( buffer, PROFILE_GetConfigDir() );
 418         p = buffer + strlen(buffer);
 419         *p++ = '/';
 420         strcpy( p, strrchr( CurProfile->dos_name, '\\' ) + 1 );
 421         CharLowerA( p );
 422         file = fopen( buffer, "w" );
 423         unix_name = buffer;
 424     }
 425
 426     if (!file)
 427     {
 428         WARN("could not save profile file %s\n", CurProfile->dos_name);
 429         return FALSE;
 430     }
 431
 432     TRACE("Saving '%s' into '%s'\n", CurProfile->dos_name, unix_name );
 433     PROFILE_Save( file, CurProfile->section );
 434     fclose( file );
 435     CurProfile->changed = FALSE;
 436     if(!stat(unix_name,&buf))
 437        CurProfile->mtime=buf.st_mtime;
 438     return TRUE;
 439 }
 440
 441
 442 /***********************************************************************
 443  *           PROFILE_ReleaseFile
 444  *
 445  * Flush the current profile to disk and remove it from the cache.
 446  */
 447 static void PROFILE_ReleaseFile(void)
 448 {
 449     PROFILE_FlushFile();
 450     PROFILE_Free( CurProfile->section );
 451     if (CurProfile->dos_name) HeapFree( SystemHeap, 0, CurProfile->dos_name );
 452     if (CurProfile->unix_name) HeapFree( SystemHeap, 0, CurProfile->unix_name );
 453     if (CurProfile->filename) HeapFree( SystemHeap, 0, CurProfile->filename );
 454     CurProfile->changed   = FALSE;
 455     CurProfile->section   = NULL;
 456     CurProfile->dos_name  = NULL;
 457     CurProfile->unix_name = NULL;
 458     CurProfile->filename  = NULL;
 459     CurProfile->mtime     = 0;
 460 }
 461
 462
 463 /***********************************************************************
 464  *           PROFILE_Open
 465  *
 466  * Open a profile file, checking the cached file first.
 467  */
 468 static BOOL PROFILE_Open( LPCSTR filename )
 469 {
 470     DOS_FULL_NAME full_name;
 471     char buffer[MAX_PATHNAME_LEN];
 472     char *newdos_name, *p;
 473     FILE *file = NULL;
 474     int i,j;
 475     struct stat buf;
 476     PROFILE *tempProfile;
 477
 478     /* First time around */
 479
 480     if(!CurProfile)
 481        for(i=0;i<N_CACHED_PROFILES;i++)
 482          {
 483           MRUProfile[i]=HEAP_xalloc( SystemHeap, 0, sizeof(PROFILE) );
 484           MRUProfile[i]->changed=FALSE;
 485           MRUProfile[i]->section=NULL;
 486           MRUProfile[i]->dos_name=NULL;
 487           MRUProfile[i]->unix_name=NULL;
 488           MRUProfile[i]->filename=NULL;
 489           MRUProfile[i]->mtime=0;
 490          }
 491
 492     /* Check for a match */
 493
 494     if (strchr( filename, '/' ) || strchr( filename, '\\' ) ||
 495         strchr( filename, ':' ))
 496     {
 497         if (!DOSFS_GetFullName( filename, FALSE, &full_name )) return FALSE;
 498     }
 499     else
 500     {
 501         GetWindowsDirectoryA( buffer, sizeof(buffer) );
 502         strcat( buffer, "\\" );
 503         strcat( buffer, filename );
 504         if (!DOSFS_GetFullName( buffer, FALSE, &full_name )) return FALSE;
 505     }
 506
 507     for(i=0;i<N_CACHED_PROFILES;i++)
 508       {
 509        if ((MRUProfile[i]->filename && !strcmp( filename, MRUProfile[i]->filename )) ||
 510            (MRUProfile[i]->dos_name && !strcmp( full_name.short_name, MRUProfile[i]->dos_name )))
 511          {
 512           if(i)
 513             {
 514              PROFILE_FlushFile();
 515              tempProfile=MRUProfile[i];
 516              for(j=i;j>0;j--)
 517                 MRUProfile[j]=MRUProfile[j-1];
 518              CurProfile=tempProfile;
 519             }
 520           if(!stat(CurProfile->unix_name,&buf) && CurProfile->mtime==buf.st_mtime)
 521              TRACE("(%s): already opened (mru=%d)\n",
 522                               filename, i );
 523           else
 524               TRACE("(%s): already opened, needs refreshing (mru=%d)\n",
 525                              filename, i );
 526           return TRUE;
 527          }
 528       }
 529
 530     /* Flush the old current profile */
 531     PROFILE_FlushFile();
 532
 533     /* Make the oldest profile the current one only in order to get rid of it */
 534     if(i==N_CACHED_PROFILES)
 535       {
 536        tempProfile=MRUProfile[N_CACHED_PROFILES-1];
 537        for(i=N_CACHED_PROFILES-1;i>0;i--)
 538           MRUProfile[i]=MRUProfile[i-1];
 539        CurProfile=tempProfile;
 540       }
 541     if(CurProfile->filename) PROFILE_ReleaseFile();
 542
 543     /* OK, now that CurProfile is definitely free we assign it our new file */
 544     newdos_name = HEAP_strdupA( SystemHeap, 0, full_name.short_name );
 545     CurProfile->dos_name  = newdos_name;
 546     CurProfile->filename  = HEAP_strdupA( SystemHeap, 0, filename );
 547
 548     /* Try to open the profile file, first in $HOME/.wine */
 549
 550     /* FIXME: this will need a more general solution */
 551     strcpy( buffer, PROFILE_GetConfigDir() );
 552     p = buffer + strlen(buffer);
 553     *p++ = '/';
 554     strcpy( p, strrchr( newdos_name, '\\' ) + 1 );
 555     CharLowerA( p );
 556     if ((file = fopen( buffer, "r" )))
 557     {
 558         TRACE("(%s): found it in %s\n",
 559               filename, buffer );
 560         CurProfile->unix_name = HEAP_strdupA( SystemHeap, 0, buffer );
 561     }
 562
 563     if (!file)
 564     {
 565         CurProfile->unix_name = HEAP_strdupA( SystemHeap, 0,
 566                                              full_name.long_name );
 567         if ((file = fopen( full_name.long_name, "r" )))
 568             TRACE("(%s): found it in %s\n",
 569                              filename, full_name.long_name );
 570     }
 571
 572     if (file)
 573     {
 574         CurProfile->section = PROFILE_Load( file );
 575         fclose( file );
 576         if(!stat(CurProfile->unix_name,&buf))
 577            CurProfile->mtime=buf.st_mtime;
 578     }
 579     else
 580     {
 581         /* Does not exist yet, we will create it in PROFILE_FlushFile */
 582         WARN("profile file %s not found\n", newdos_name );
 583     }
 584     return TRUE;
 585 }
 586
 587
 588 /***********************************************************************
 589  *           PROFILE_GetSection
 590  *
 591  * Returns all keys of a section.
 592  * If return_values is TRUE, also include the corresponding values.
 593  */
 594 static INT PROFILE_GetSection( PROFILESECTION *section, LPCSTR section_name,
 595                                LPSTR buffer, UINT len, BOOL handle_env,
 596                                BOOL return_values )
 597 {
 598     PROFILEKEY *key;
 599     while (section)
 600     {
 601         if (section->name && !strcasecmp( section->name, section_name ))
 602         {
 603             UINT oldlen = len;
 604             for (key = section->key; key; key = key->next)
 605             {
 606                 if (len <= 2) break;
 607                 if (!*key->name) continue;  /* Skip empty lines */
 608                 if (IS_ENTRY_COMMENT(key->name)) continue;  /* Skip comments */
 609                 PROFILE_CopyEntry( buffer, key->name, len - 1, handle_env );
 610                 len -= strlen(buffer) + 1;
 611                 buffer += strlen(buffer) + 1;
 612                 if (return_values && key->value) {
 613                         buffer[-1] = '=';
 614                         PROFILE_CopyEntry ( buffer,
 615                                 key->value, len - 1, handle_env );
 616                         len -= strlen(buffer) + 1;
 617                         buffer += strlen(buffer) + 1;
 618                 }
 619             }
 620             *buffer = '\0';
 621             if (len <= 1)
 622                 /*If either lpszSection or lpszKey is NULL and the supplied
 623                   destination buffer is too small to hold all the strings,
 624                   the last string is truncated and followed by two null characters.
 625                   In this case, the return value is equal to cchReturnBuffer
 626                   minus two. */
 627             {
 628                 buffer[-1] = '\0';
 629                 return oldlen - 2;
 630             }
 631             return oldlen - len;
 632         }
 633         section = section->next;
 634     }
 635     buffer[0] = buffer[1] = '\0';
 636     return 0;
 637 }
 638
 639
 640 static INT PROFILE_GetSectionNames( LPSTR buffer, UINT len )
 641 {
 642     LPSTR buf = buffer;
 643     WORD l, cursize = 0;
 644     PROFILESECTION *section;
 645
 646     for (section = CurProfile->section; section; section = section->next)
 647         if (section->name) {
 648             l = strlen(section->name);
 649             cursize += l+1;
 650             if (cursize > len+1)
 651                 return len-2;
 652
 653             strcpy(buf, section->name);
 654             buf += l+1;
 655         }
 656
 657     *buf=0;
 658     buf++;
 659     return buf-buffer;
 660 }
 661
 662
 663 /***********************************************************************
 664  *           PROFILE_GetString
 665  *
 666  * Get a profile string.
 667  */
 668 static INT PROFILE_GetString( LPCSTR section, LPCSTR key_name,
 669                               LPCSTR def_val, LPSTR buffer, UINT len )
 670 {
 671     PROFILEKEY *key = NULL;
 672
 673     if (!def_val) def_val = "";
 674     if (key_name && key_name[0])
 675     {
 676         key = PROFILE_Find( &CurProfile->section, section, key_name, FALSE );
 677         PROFILE_CopyEntry( buffer, (key && key->value) ? key->value : def_val,
 678                            len, FALSE );
 679         TRACE("('%s','%s','%s'): returning '%s'\n",
 680                          section, key_name, def_val, buffer );
 681         return strlen( buffer );
 682     }
 683     if (section && section[0])
 684         return PROFILE_GetSection(CurProfile->section, section, buffer, len,
 685                                 FALSE, FALSE);
 686     /* undocumented; both section and key_name are NULL */
 687     return PROFILE_GetSectionNames(buffer, len);
 688 }
 689
 690
 691 /***********************************************************************
 692  *           PROFILE_SetString
 693  *
 694  * Set a profile string.
 695  */
 696 static BOOL PROFILE_SetString( LPCSTR section_name, LPCSTR key_name,
 697                                LPCSTR value )
 698 {
 699     if (!key_name)  /* Delete a whole section */
 700     {
 701         TRACE("('%s')\n", section_name);
 702         CurProfile->changed |= PROFILE_DeleteSection( &CurProfile->section,
 703                                                       section_name );
 704         return TRUE;         /* Even if PROFILE_DeleteSection() has failed,
 705                                 this is not an error on application's level.*/
 706     }
 707     else if (!value)  /* Delete a key */
 708     {
 709         TRACE("('%s','%s')\n",
 710                          section_name, key_name );
 711         CurProfile->changed |= PROFILE_DeleteKey( &CurProfile->section,
 712                                                   section_name, key_name );
 713         return TRUE;          /* same error handling as above */
 714     }
 715     else  /* Set the key value */
 716     {
 717         PROFILEKEY *key = PROFILE_Find( &CurProfile->section, section_name,
 718                                         key_name, TRUE );
 719         TRACE("('%s','%s','%s'): \n",
 720                          section_name, key_name, value );
 721         if (!key) return FALSE;
 722         if (key->value)
 723         {
 724             if (!strcmp( key->value, value ))
 725             {
 726                 TRACE("  no change needed\n" );
 727                 return TRUE;  /* No change needed */
 728             }
 729             TRACE("  replacing '%s'\n", key->value );
 730             HeapFree( SystemHeap, 0, key->value );
 731         }
 732         else TRACE("  creating key\n" );
 733         key->value = HEAP_strdupA( SystemHeap, 0, value );
 734         CurProfile->changed = TRUE;
 735     }
 736     return TRUE;
 737 }
 738
 739
 740 /***********************************************************************
 741  *           PROFILE_GetWineIniString
 742  *
 743  * Get a config string from the wine.ini file.
 744  */
 745 int PROFILE_GetWineIniString( const char *section, const char *key_name,
 746                               const char *def, char *buffer, int len )
 747 {
 748     int ret;
 749
 750     EnterCriticalSection( &PROFILE_CritSect );
 751
 752     if (key_name)
 753     {
 754         PROFILEKEY *key = PROFILE_Find(&PROFILE_WineProfile, section, key_name, FALSE);
 755         PROFILE_CopyEntry( buffer, (key && key->value) ? key->value : def,
 756                            len, TRUE );
 757         TRACE("('%s','%s','%s'): returning '%s'\n",
 758                          section, key_name, def, buffer );
 759         ret = strlen( buffer );
 760     }
 761     else
 762     {
 763        ret = PROFILE_GetSection( PROFILE_WineProfile, section, buffer, len, TRUE, FALSE );
 764     }
 765     LeaveCriticalSection( &PROFILE_CritSect );
 766
 767     return ret;
 768 }
 769
 770
 771 /***********************************************************************
 772  *           PROFILE_GetWineIniInt
 773  *
 774  * Get a config integer from the wine.ini file.
 775  */
 776 int PROFILE_GetWineIniInt( const char *section, const char *key_name, int def )
 777 {
 778     char buffer[20];
 779     char *p;
 780     long result;
 781     PROFILEKEY *key;
 782     int ret;
 783
 784     EnterCriticalSection( &PROFILE_CritSect );
 785
 786     key = PROFILE_Find( &PROFILE_WineProfile, section, key_name, FALSE );
 787     if (!key || !key->value) {
 788        ret = def;
 789     } else {
 790        PROFILE_CopyEntry( buffer, key->value, sizeof(buffer), TRUE );
 791        result = strtol( buffer, &p, 0 );
 792        ret = (p == buffer) ? 0  /* No digits at all */ : (int)result;
 793     }
 794
 795     LeaveCriticalSection( &PROFILE_CritSect );
 796
 797     return ret;
 798 }
 799
 800
 801 /******************************************************************************
 802  *
 803  *   int  PROFILE_EnumerateWineIniSection(
 804  *     char const  *section,  #Name of the section to enumerate
 805  *     void  (*cbfn)(char const *key, char const *value, void *user),
 806  *                            # Address of the callback function
 807  *     void  *user )          # User-specified pointer.
 808  *
 809  *   For each entry in a section in the wine.conf file, this function will
 810  *   call the specified callback function, informing it of each key and
 811  *   value.  An optional user pointer may be passed to it (if this is not
 812  *   needed, pass NULL through it and ignore the value in the callback
 813  *   function).
 814  *
 815  *   The callback function must accept three parameters:
 816  *      The name of the key (char const *)
 817  *      The value of the key (char const *)
 818  *      A user-specified parameter (void *)
 819  *   Note that the first two are char CONST *'s, not char *'s!  The callback
 820  *   MUST not modify these strings!
 821  *
 822  *   The return value indicates the number of times the callback function
 823  *   was called.
 824  */
 825 int  PROFILE_EnumerateWineIniSection(
 826     char const  *section,
 827     void  (*cbfn)(char const *, char const *, void *),
 828     void  *userptr )
 829 {
 830     PROFILESECTION  *scansect;
 831     PROFILEKEY  *scankey;
 832     int  calls = 0;
 833
 834     EnterCriticalSection( &PROFILE_CritSect );
 835
 836     /* Search for the correct section */
 837     for(scansect = PROFILE_WineProfile; scansect; scansect = scansect->next) {
 838         if(scansect->name && !strcasecmp(scansect->name, section)) {
 839
 840             /* Enumerate each key with the callback */
 841             for(scankey = scansect->key; scankey; scankey = scankey->next) {
 842
 843                 /* Ignore blank entries -- these shouldn't exist, but let's
 844                    be extra careful */
 845                 if (!scankey->name[0]) continue;
 846                 if (!scankey->value) cbfn(scankey->name, NULL, userptr);
 847                 else
 848                 {
 849                     char value[1024];
 850                     PROFILE_CopyEntry(value, scankey->value, sizeof(value), TRUE);
 851                     cbfn(scankey->name, value, userptr);
 852                 }
 853                 ++calls;
 854             }
 855
 856             break;
 857         }
 858     }
 859     LeaveCriticalSection( &PROFILE_CritSect );
 860
 861     return calls;
 862 }
 863
 864
 865 /******************************************************************************
 866  *
 867  *   int  PROFILE_GetWineIniBool(
 868  *      char const  *section,
 869  *      char const  *key_name,
 870  *      int  def )
 871  *
 872  *   Reads a boolean value from the wine.ini file.  This function attempts to
 873  *   be user-friendly by accepting 'n', 'N' (no), 'f', 'F' (false), or '0'
 874  *   (zero) for false, 'y', 'Y' (yes), 't', 'T' (true), or '1' (one) for
 875  *   true.  Anything else results in the return of the default value.
 876  *
 877  *   This function uses 1 to indicate true, and 0 for false.  You can check
 878  *   for existence by setting def to something other than 0 or 1 and
 879  *   examining the return value.
 880  */
 881 int  PROFILE_GetWineIniBool(
 882     char const  *section,
 883     char const  *key_name,
 884     int  def )
 885 {
 886     char  key_value[2];
 887     int  retval;
 888
 889     PROFILE_GetWineIniString(section, key_name, "~", key_value, 2);
 890
 891     switch(key_value[0]) {
 892     case 'n':
 893     case 'N':
 894     case 'f':
 895     case 'F':
 896     case '0':
 897         retval = 0;
 898         break;
 899
 900     case 'y':
 901     case 'Y':
 902     case 't':
 903     case 'T':
 904     case '1':
 905         retval = 1;
 906         break;
 907
 908     default:
 909         retval = def;
 910     }
 911
 912     TRACE("(\"%s\", \"%s\", %s), "
 913                     "[%c], ret %s.\n", section, key_name,
 914                     def ? "TRUE" : "FALSE", key_value[0],
 915                     retval ? "TRUE" : "FALSE");
 916
 917     return retval;
 918 }
 919
 920
 921 /***********************************************************************
 922  *           PROFILE_LoadWineIni
 923  *
 924  * Load the wine.ini file.
 925  */
 926 int PROFILE_LoadWineIni(void)
 927 {
 928     char buffer[MAX_PATHNAME_LEN];
 929     const char *p;
 930     FILE *f;
 931
 932     InitializeCriticalSection( &PROFILE_CritSect );
 933     MakeCriticalSectionGlobal( &PROFILE_CritSect );
 934
 935     if ( (Options.configFileName!=NULL) && (f = fopen(Options.configFileName, "r")) )
 936     {
 937       /* Open -config specified file */
 938       PROFILE_WineProfile = PROFILE_Load ( f);
 939       fclose ( f );
 940       lstrcpynA(PROFILE_WineIniUsed,Options.configFileName,MAX_PATHNAME_LEN);
 941       return 1;
 942     }
 943
 944     if ( (p = getenv( "WINE_INI" )) && (f = fopen( p, "r" )) )
 945     {
 946         PROFILE_WineProfile = PROFILE_Load( f );
 947         fclose( f );
 948         lstrcpynA(PROFILE_WineIniUsed,p,MAX_PATHNAME_LEN);
 949         return 1;
 950     }
 951     if ((p = getenv( "HOME" )) != NULL)
 952     {
 953         lstrcpynA(buffer, p, MAX_PATHNAME_LEN - sizeof(PROFILE_WineIniName));
 954         strcat( buffer, PROFILE_WineIniName );
 955         if ((f = fopen( buffer, "r" )) != NULL)
 956         {
 957             PROFILE_WineProfile = PROFILE_Load( f );
 958             fclose( f );
 959             lstrcpynA(PROFILE_WineIniUsed,buffer,MAX_PATHNAME_LEN);
 960             return 1;
 961         }
 962     }
 963     else WARN("could not get $HOME value for config file.\n" );
 964
 965     /* Try global file */
 966
 967     if ((f = fopen( WINE_INI_GLOBAL, "r" )) != NULL)
 968     {
 969         PROFILE_WineProfile = PROFILE_Load( f );
 970         fclose( f );
 971         lstrcpynA(PROFILE_WineIniUsed,WINE_INI_GLOBAL,MAX_PATHNAME_LEN);
 972         return 1;
 973     }
 974     MESSAGE( "Can't open configuration file %s or $HOME%s\n",
 975          WINE_INI_GLOBAL, PROFILE_WineIniName );
 976     return 0;
 977 }
 978
 979
 980 /***********************************************************************
 981  *           PROFILE_UsageWineIni
 982  *
 983  * Explain the wine.ini file to those who don't read documentation.
 984  * Keep below one screenful in length so that error messages above are
 985  * noticed.
 986  */
 987 void PROFILE_UsageWineIni(void)
 988 {
 989     MESSAGE("Perhaps you have not properly edited or created "
 990         "your Wine configuration file.\n");
 991     MESSAGE("This is either %s or $HOME%s\n",WINE_INI_GLOBAL,PROFILE_WineIniName);
 992     MESSAGE("  or it is determined by the -config option or from\n"
 993         "  the WINE_INI environment variable.\n");
 994     if (*PROFILE_WineIniUsed)
 995         MESSAGE("Wine has used %s as configuration file.\n", PROFILE_WineIniUsed);
 996     /* RTFM, so to say */
 997 }
 998
 999 /***********************************************************************
1000  *           PROFILE_GetStringItem
1001  *
1002  *  Convenience function that turns a string 'xxx, yyy, zzz' into
1003  *  the 'xxx\0 yyy, zzz' and returns a pointer to the 'yyy, zzz'.
1004  */
1005 char* PROFILE_GetStringItem( char* start )
1006 {
1007     char* lpchX, *lpch;
1008
1009     for (lpchX = start, lpch = NULL; *lpchX != '\0'; lpchX++ )
1010     {
1011         if( *lpchX == ',' )
1012         {
1013             if( lpch ) *lpch = '\0'; else *lpchX = '\0';
1014             while( *(++lpchX) )
1015                 if( !PROFILE_isspace(*lpchX) ) return lpchX;
1016         }
1017         else if( PROFILE_isspace( *lpchX ) && !lpch ) lpch = lpchX;
1018              else lpch = NULL;
1019     }
1020     if( lpch ) *lpch = '\0';
1021     return NULL;
1022 }
1023
1024 /********************* API functions **********************************/
1025
1026 /***********************************************************************
1027  *           GetProfileInt16   (KERNEL.57)
1028  */
1029 UINT16 WINAPI GetProfileInt16( LPCSTR section, LPCSTR entry, INT16 def_val )
1030 {
1031     return GetPrivateProfileInt16( section, entry, def_val, "win.ini" );
1032 }
1033
1034
1035 /***********************************************************************
1036  *           GetProfileInt32A   (KERNEL32.264)
1037  */
1038 UINT WINAPI GetProfileIntA( LPCSTR section, LPCSTR entry, INT def_val )
1039 {
1040     return GetPrivateProfileIntA( section, entry, def_val, "win.ini" );
1041 }
1042
1043 /***********************************************************************
1044  *           GetProfileInt32W   (KERNEL32.264)
1045  */
1046 UINT WINAPI GetProfileIntW( LPCWSTR section, LPCWSTR entry, INT def_val )
1047 {
1048     if (!wininiW) wininiW = HEAP_strdupAtoW( SystemHeap, 0, "win.ini" );
1049     return GetPrivateProfileIntW( section, entry, def_val, wininiW );
1050 }
1051
1052 /***********************************************************************
1053  *           GetProfileString16   (KERNEL.58)
1054  */
1055 INT16 WINAPI GetProfileString16( LPCSTR section, LPCSTR entry, LPCSTR def_val,
1056                                  LPSTR buffer, UINT16 len )
1057 {
1058     return GetPrivateProfileString16( section, entry, def_val,
1059                                       buffer, len, "win.ini" );
1060 }
1061
1062 /***********************************************************************
1063  *           GetProfileString32A   (KERNEL32.268)
1064  */
1065 INT WINAPI GetProfileStringA( LPCSTR section, LPCSTR entry, LPCSTR def_val,
1066                               LPSTR buffer, UINT len )
1067 {
1068     return GetPrivateProfileStringA( section, entry, def_val,
1069                                      buffer, len, "win.ini" );
1070 }
1071
1072 /***********************************************************************
1073  *           GetProfileString32W   (KERNEL32.269)
1074  */
1075 INT WINAPI GetProfileStringW( LPCWSTR section, LPCWSTR entry,
1076                               LPCWSTR def_val, LPWSTR buffer, UINT len )
1077 {
1078     if (!wininiW) wininiW = HEAP_strdupAtoW( SystemHeap, 0, "win.ini" );
1079     return GetPrivateProfileStringW( section, entry, def_val,
1080                                      buffer, len, wininiW );
1081 }
1082
1083 /***********************************************************************
1084  *           WriteProfileString16   (KERNEL.59)
1085  */
1086 BOOL16 WINAPI WriteProfileString16( LPCSTR section, LPCSTR entry,
1087                                     LPCSTR string )
1088 {
1089     return WritePrivateProfileString16( section, entry, string, "win.ini" );
1090 }
1091
1092 /***********************************************************************
1093  *           WriteProfileString32A   (KERNEL32.587)
1094  */
1095 BOOL WINAPI WriteProfileStringA( LPCSTR section, LPCSTR entry,
1096                                  LPCSTR string )
1097 {
1098     return WritePrivateProfileStringA( section, entry, string, "win.ini" );
1099 }
1100
1101 /***********************************************************************
1102  *           WriteProfileString32W   (KERNEL32.588)
1103  */
1104 BOOL WINAPI WriteProfileStringW( LPCWSTR section, LPCWSTR entry,
1105                                      LPCWSTR string )
1106 {
1107     if (!wininiW) wininiW = HEAP_strdupAtoW( SystemHeap, 0, "win.ini" );
1108     return WritePrivateProfileStringW( section, entry, string, wininiW );
1109 }
1110
1111
1112 /***********************************************************************
1113  *           GetPrivateProfileInt16   (KERNEL.127)
1114  */
1115 UINT16 WINAPI GetPrivateProfileInt16( LPCSTR section, LPCSTR entry,
1116                                       INT16 def_val, LPCSTR filename )
1117 {
1118     long result=(long)GetPrivateProfileIntA(section,entry,def_val,filename);
1119
1120     if (result > 65535) return 65535;
1121     if (result >= 0) return (UINT16)result;
1122     if (result < -32768) return -32768;
1123     return (UINT16)(INT16)result;
1124 }
1125
1126 /***********************************************************************
1127  *           GetPrivateProfileInt32A   (KERNEL32.251)
1128  */
1129 UINT WINAPI GetPrivateProfileIntA( LPCSTR section, LPCSTR entry,
1130                                    INT def_val, LPCSTR filename )
1131 {
1132     char buffer[20];
1133     char *p;
1134     long result;
1135
1136     GetPrivateProfileStringA( section, entry, "",
1137                                 buffer, sizeof(buffer), filename );
1138     if (!buffer[0]) return (UINT)def_val;
1139     result = strtol( buffer, &p, 0 );
1140     if (p == buffer) return 0;  /* No digits at all */
1141     return (UINT)result;
1142 }
1143
1144 /***********************************************************************
1145  *           GetPrivateProfileInt32W   (KERNEL32.252)
1146  */
1147 UINT WINAPI GetPrivateProfileIntW( LPCWSTR section, LPCWSTR entry,
1148                                    INT def_val, LPCWSTR filename )
1149 {
1150     LPSTR sectionA  = HEAP_strdupWtoA( GetProcessHeap(), 0, section );
1151     LPSTR entryA    = HEAP_strdupWtoA( GetProcessHeap(), 0, entry );
1152     LPSTR filenameA = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
1153     UINT res = GetPrivateProfileIntA(sectionA, entryA, def_val, filenameA);
1154     HeapFree( GetProcessHeap(), 0, sectionA );
1155     HeapFree( GetProcessHeap(), 0, filenameA );
1156     HeapFree( GetProcessHeap(), 0, entryA );
1157     return res;
1158 }
1159
1160 /***********************************************************************
1161  *           GetPrivateProfileString16   (KERNEL.128)
1162  */
1163 INT16 WINAPI GetPrivateProfileString16( LPCSTR section, LPCSTR entry,
1164                                         LPCSTR def_val, LPSTR buffer,
1165                                         UINT16 len, LPCSTR filename )
1166 {
1167     return GetPrivateProfileStringA(section,entry,def_val,buffer,len,filename);
1168 }
1169
1170 /***********************************************************************
1171  *           GetPrivateProfileString32A   (KERNEL32.255)
1172  */
1173 INT WINAPI GetPrivateProfileStringA( LPCSTR section, LPCSTR entry,
1174                                      LPCSTR def_val, LPSTR buffer,
1175                                      UINT len, LPCSTR filename )
1176 {
1177     int         ret;
1178
1179     if (!filename)
1180         filename = "win.ini";
1181
1182     EnterCriticalSection( &PROFILE_CritSect );
1183
1184     if (PROFILE_Open( filename )) {
1185         ret = PROFILE_GetString( section, entry, def_val, buffer, len );
1186     } else {
1187        lstrcpynA( buffer, def_val, len );
1188        ret = strlen( buffer );
1189     }
1190
1191     LeaveCriticalSection( &PROFILE_CritSect );
1192
1193     return ret;
1194 }
1195
1196 /***********************************************************************
1197  *           GetPrivateProfileString32W   (KERNEL32.256)
1198  */
1199 INT WINAPI GetPrivateProfileStringW( LPCWSTR section, LPCWSTR entry,
1200                                      LPCWSTR def_val, LPWSTR buffer,
1201                                      UINT len, LPCWSTR filename )
1202 {
1203     LPSTR sectionA  = HEAP_strdupWtoA( GetProcessHeap(), 0, section );
1204     LPSTR entryA    = HEAP_strdupWtoA( GetProcessHeap(), 0, entry );
1205     LPSTR filenameA = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
1206     LPSTR def_valA  = HEAP_strdupWtoA( GetProcessHeap(), 0, def_val );
1207     LPSTR bufferA   = HeapAlloc( GetProcessHeap(), 0, len );
1208     INT ret = GetPrivateProfileStringA( sectionA, entryA, def_valA,
1209                                             bufferA, len, filenameA );
1210     lstrcpynAtoW( buffer, bufferA, len );
1211     HeapFree( GetProcessHeap(), 0, sectionA );
1212     HeapFree( GetProcessHeap(), 0, entryA );
1213     HeapFree( GetProcessHeap(), 0, filenameA );
1214     HeapFree( GetProcessHeap(), 0, def_valA );
1215     HeapFree( GetProcessHeap(), 0, bufferA);
1216     return ret;
1217 }
1218
1219 /***********************************************************************
1220  *           GetPrivateProfileSection16   (KERNEL.418)
1221  */
1222 INT16 WINAPI GetPrivateProfileSection16( LPCSTR section, LPSTR buffer,
1223                                         UINT16 len, LPCSTR filename )
1224 {
1225     return GetPrivateProfileSectionA( section, buffer, len, filename );
1226 }
1227
1228 /***********************************************************************
1229  *           GetPrivateProfileSection32A   (KERNEL32.255)
1230  */
1231 INT WINAPI GetPrivateProfileSectionA( LPCSTR section, LPSTR buffer,
1232                                       DWORD len, LPCSTR filename )
1233 {
1234     int         ret = 0;
1235
1236     EnterCriticalSection( &PROFILE_CritSect );
1237
1238     if (PROFILE_Open( filename ))
1239         ret = PROFILE_GetSection(CurProfile->section, section, buffer, len,
1240                                  FALSE, TRUE);
1241
1242     LeaveCriticalSection( &PROFILE_CritSect );
1243
1244     return ret;
1245 }
1246
1247 /***********************************************************************
1248  *           GetPrivateProfileSection32W   (KERNEL32.256)
1249  */
1250
1251 INT WINAPI GetPrivateProfileSectionW (LPCWSTR section, LPWSTR buffer,
1252                                       DWORD len, LPCWSTR filename )
1253
1254 {
1255     LPSTR sectionA  = HEAP_strdupWtoA( GetProcessHeap(), 0, section );
1256     LPSTR filenameA = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
1257     LPSTR bufferA   = HeapAlloc( GetProcessHeap(), 0, len );
1258     INT ret = GetPrivateProfileSectionA( sectionA, bufferA, len,
1259                                                 filenameA );
1260     MultiByteToWideChar(CP_ACP,0,bufferA,ret,buffer,len);
1261     HeapFree( GetProcessHeap(), 0, sectionA );
1262     HeapFree( GetProcessHeap(), 0, filenameA );
1263     HeapFree( GetProcessHeap(), 0, bufferA);
1264     return ret;
1265 }
1266
1267 /***********************************************************************
1268  *           GetProfileSection16   (KERNEL.419)
1269  */
1270 INT16 WINAPI GetProfileSection16( LPCSTR section, LPSTR buffer, UINT16 len )
1271 {
1272     return GetPrivateProfileSection16( section, buffer, len, "win.ini" );
1273 }
1274
1275 /***********************************************************************
1276  *           GetProfileSection32A   (KERNEL32.268)
1277  */
1278 INT WINAPI GetProfileSectionA( LPCSTR section, LPSTR buffer, DWORD len )
1279 {
1280     return GetPrivateProfileSectionA( section, buffer, len, "win.ini" );
1281 }
1282
1283 /***********************************************************************
1284  *           GetProfileSection32W   (KERNEL32)
1285  */
1286 INT WINAPI GetProfileSectionW( LPCWSTR section, LPWSTR buffer, DWORD len )
1287 {
1288     if (!wininiW) wininiW = HEAP_strdupAtoW( SystemHeap, 0, "win.ini" );
1289     return GetPrivateProfileSectionW( section, buffer, len, wininiW );
1290 }
1291
1292
1293 /***********************************************************************
1294  *           WritePrivateProfileString16   (KERNEL.129)
1295  */
1296 BOOL16 WINAPI WritePrivateProfileString16( LPCSTR section, LPCSTR entry,
1297                                            LPCSTR string, LPCSTR filename )
1298 {
1299     return WritePrivateProfileStringA(section,entry,string,filename);
1300 }
1301
1302 /***********************************************************************
1303  *           WritePrivateProfileString32A   (KERNEL32.582)
1304  */
1305 BOOL WINAPI WritePrivateProfileStringA( LPCSTR section, LPCSTR entry,
1306                                         LPCSTR string, LPCSTR filename )
1307 {
1308     BOOL ret = FALSE;
1309
1310     EnterCriticalSection( &PROFILE_CritSect );
1311
1312     if (PROFILE_Open( filename ))
1313     {
1314         if (!section && !entry && !string)
1315             PROFILE_ReleaseFile();  /* always return FALSE in this case */
1316         else
1317             ret = PROFILE_SetString( section, entry, string );
1318     }
1319
1320     LeaveCriticalSection( &PROFILE_CritSect );
1321     return ret;
1322 }
1323
1324 /***********************************************************************
1325  *           WritePrivateProfileString32W   (KERNEL32.583)
1326  */
1327 BOOL WINAPI WritePrivateProfileStringW( LPCWSTR section, LPCWSTR entry,
1328                                         LPCWSTR string, LPCWSTR filename )
1329 {
1330     LPSTR sectionA  = HEAP_strdupWtoA( GetProcessHeap(), 0, section );
1331     LPSTR entryA    = HEAP_strdupWtoA( GetProcessHeap(), 0, entry );
1332     LPSTR stringA   = HEAP_strdupWtoA( GetProcessHeap(), 0, string );
1333     LPSTR filenameA = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
1334     BOOL res = WritePrivateProfileStringA( sectionA, entryA,
1335                                            stringA, filenameA );
1336     HeapFree( GetProcessHeap(), 0, sectionA );
1337     HeapFree( GetProcessHeap(), 0, entryA );
1338     HeapFree( GetProcessHeap(), 0, stringA );
1339     HeapFree( GetProcessHeap(), 0, filenameA );
1340     return res;
1341 }
1342
1343 /***********************************************************************
1344  *           WritePrivateProfileSection16   (KERNEL.416)
1345  */
1346 BOOL16 WINAPI WritePrivateProfileSection16( LPCSTR section,
1347                                             LPCSTR string, LPCSTR filename )
1348 {
1349     return WritePrivateProfileSectionA( section, string, filename );
1350 }
1351
1352 /***********************************************************************
1353  *           WritePrivateProfileSectionA   (KERNEL32)
1354  */
1355 BOOL WINAPI WritePrivateProfileSectionA( LPCSTR section,
1356                                          LPCSTR string, LPCSTR filename )
1357 {
1358     BOOL ret = FALSE;
1359     LPSTR p ;
1360
1361     EnterCriticalSection( &PROFILE_CritSect );
1362
1363     if (PROFILE_Open( filename )) {
1364         if (!section && !string && !filename)
1365             PROFILE_ReleaseFile();  /* always return FALSE in this case */
1366         else {
1367             while(*string){
1368                 LPSTR buf=HEAP_strdupA( GetProcessHeap(), 0, string );
1369                 if((p=strchr( buf, '='))){
1370                     *p='\0';
1371                     ret = PROFILE_SetString( section, buf, p+1 );
1372
1373                 }
1374                 HeapFree( GetProcessHeap(), 0, buf );
1375                 string += strlen(string)+1;
1376             }
1377
1378         }
1379     }
1380
1381     LeaveCriticalSection( &PROFILE_CritSect );
1382     return ret;
1383 }
1384
1385 /***********************************************************************
1386  *           WritePrivateProfileSection32W   (KERNEL32)
1387  */
1388 BOOL WINAPI WritePrivateProfileSectionW( LPCWSTR section,
1389                                          LPCWSTR string, LPCWSTR filename)
1390
1391 {
1392     LPSTR sectionA  = HEAP_strdupWtoA( GetProcessHeap(), 0, section );
1393     LPSTR stringA   = HEAP_strdupWtoA( GetProcessHeap(), 0, string );
1394     LPSTR filenameA = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
1395     BOOL res = WritePrivateProfileSectionA( sectionA, stringA, filenameA );
1396     HeapFree( GetProcessHeap(), 0, sectionA );
1397     HeapFree( GetProcessHeap(), 0, stringA );
1398     HeapFree( GetProcessHeap(), 0, filenameA );
1399     return res;
1400 }
1401
1402 /***********************************************************************
1403  *           WriteProfileSection16   (KERNEL.417)
1404  */
1405 BOOL16 WINAPI WriteProfileSection16( LPCSTR section, LPCSTR keys_n_values)
1406 {
1407     return WritePrivateProfileSection16( section, keys_n_values, "win.ini");
1408 }
1409
1410 /***********************************************************************
1411  *           WriteProfileSection32A   (KERNEL32.747)
1412  */
1413 BOOL WINAPI WriteProfileSectionA( LPCSTR section, LPCSTR keys_n_values)
1414
1415 {
1416     return WritePrivateProfileSectionA( section, keys_n_values, "win.ini");
1417 }
1418
1419 /***********************************************************************
1420  *           WriteProfileSection32W   (KERNEL32.748)
1421  */
1422 BOOL WINAPI WriteProfileSectionW( LPCWSTR section, LPCWSTR keys_n_values)
1423 {
1424    if (!wininiW) wininiW = HEAP_strdupAtoW( SystemHeap, 0, "win.ini");
1425
1426    return (WritePrivateProfileSectionW (section,keys_n_values, wininiW));
1427 }
1428
1429 /***********************************************************************
1430  *           GetPrivateProfileSectionNames16   (KERNEL.143)
1431  */
1432 WORD WINAPI GetPrivateProfileSectionNames16( LPSTR buffer, WORD size,
1433                                              LPCSTR filename )
1434 {
1435     WORD ret = 0;
1436
1437     EnterCriticalSection( &PROFILE_CritSect );
1438
1439     if (PROFILE_Open( filename ))
1440         ret = PROFILE_GetSectionNames(buffer, size);
1441
1442     LeaveCriticalSection( &PROFILE_CritSect );
1443
1444     return ret;
1445 }
1446
1447
1448 /***********************************************************************
1449  *           GetProfileSectionNames16   (KERNEL.142)
1450  */
1451 WORD WINAPI GetProfileSectionNames16( LPSTR buffer, WORD size)
1452
1453 {
1454     return (GetPrivateProfileSectionNames16 (buffer,size,"win.ini"));
1455 }
1456
1457
1458 /***********************************************************************
1459  *           GetPrivateProfileSectionNames32A  (KERNEL32.365)
1460  */
1461 DWORD WINAPI GetPrivateProfileSectionNamesA( LPSTR buffer, DWORD size,
1462                                              LPCSTR filename)
1463
1464 {
1465  return (GetPrivateProfileSectionNames16 (buffer,size,filename));
1466 }
1467
1468
1469 /***********************************************************************
1470  *           GetPrivateProfileSectionNames32W  (KERNEL32.366)
1471  */
1472 DWORD WINAPI GetPrivateProfileSectionNamesW( LPWSTR buffer, DWORD size,
1473                                              LPCWSTR filename)
1474
1475 {
1476    LPSTR filenameA = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
1477    LPSTR bufferA   = HeapAlloc( GetProcessHeap(), 0, size);
1478
1479    INT ret = GetPrivateProfileSectionNames16 (bufferA, size, filenameA);
1480    lstrcpynAtoW( buffer, bufferA, size);
1481    HeapFree( GetProcessHeap(), 0, bufferA);
1482    HeapFree( GetProcessHeap(), 0, filenameA );
1483
1484    return ret;
1485 }
1486
1487 /***********************************************************************
1488  *           GetPrivateProfileStruct16 (KERNEL.407)
1489  */
1490 BOOL16 WINAPI GetPrivateProfileStruct16(LPCSTR section, LPCSTR key,
1491                                         LPVOID buf, UINT16 len, LPCSTR filename)
1492 {
1493     return GetPrivateProfileStructA( section, key, buf, len, filename );
1494 }
1495
1496 /***********************************************************************
1497  *           GetPrivateProfileStruct32A (KERNEL32.370)
1498  */
1499 BOOL WINAPI GetPrivateProfileStructA (LPCSTR section, LPCSTR key,
1500                                       LPVOID buf, UINT len, LPCSTR filename)
1501 {
1502     BOOL        ret = FALSE;
1503
1504     EnterCriticalSection( &PROFILE_CritSect );
1505
1506     if (PROFILE_Open( filename )) {
1507         PROFILEKEY *k = PROFILE_Find ( &CurProfile->section, section, key, FALSE);
1508         if (k) {
1509            lstrcpynA( buf, k->value, strlen(k->value));
1510            ret = TRUE;
1511         }
1512     }
1513     LeaveCriticalSection( &PROFILE_CritSect );
1514
1515     return FALSE;
1516 }
1517
1518 /***********************************************************************
1519  *           GetPrivateProfileStruct32W (KERNEL32.543)
1520  */
1521 BOOL WINAPI GetPrivateProfileStructW (LPCWSTR section, LPCWSTR key,
1522                                       LPVOID buffer, UINT len, LPCWSTR filename)
1523 {
1524     LPSTR sectionA  = HEAP_strdupWtoA( GetProcessHeap(), 0, section );
1525     LPSTR keyA      = HEAP_strdupWtoA( GetProcessHeap(), 0, key);
1526     LPSTR filenameA = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
1527     LPSTR bufferA   = HeapAlloc( GetProcessHeap(), 0, len );
1528
1529     INT ret = GetPrivateProfileStructA( sectionA, keyA, bufferA,
1530                                         len, filenameA );
1531     lstrcpynAtoW( buffer, bufferA, len );
1532     HeapFree( GetProcessHeap(), 0, bufferA);
1533     HeapFree( GetProcessHeap(), 0, sectionA );
1534     HeapFree( GetProcessHeap(), 0, keyA );
1535     HeapFree( GetProcessHeap(), 0, filenameA );
1536
1537     return ret;
1538 }
1539
1540
1541
1542 /***********************************************************************
1543  *           WritePrivateProfileStruct16 (KERNEL.406)
1544  */
1545 BOOL16 WINAPI WritePrivateProfileStruct16 (LPCSTR section, LPCSTR key,
1546         LPVOID buf, UINT16 bufsize, LPCSTR filename)
1547 {
1548     return WritePrivateProfileStructA( section, key, buf, bufsize, filename );
1549 }
1550
1551 /***********************************************************************
1552  *           WritePrivateProfileStruct32A (KERNEL32.744)
1553  */
1554 BOOL WINAPI WritePrivateProfileStructA (LPCSTR section, LPCSTR key,
1555                                         LPVOID buf, UINT bufsize, LPCSTR filename)
1556 {
1557     BOOL ret = FALSE;
1558
1559     if (!section && !key && !buf)  /* flush the cache */
1560         return WritePrivateProfileStringA( NULL, NULL, NULL, filename );
1561
1562     EnterCriticalSection( &PROFILE_CritSect );
1563
1564     if (PROFILE_Open( filename ))
1565         ret = PROFILE_SetString( section, key, buf );
1566
1567     LeaveCriticalSection( &PROFILE_CritSect );
1568
1569     return ret;
1570 }
1571
1572 /***********************************************************************
1573  *           WritePrivateProfileStruct32W (KERNEL32.544)
1574  */
1575 BOOL WINAPI WritePrivateProfileStructW (LPCWSTR section, LPCWSTR key,
1576                                         LPVOID buf, UINT bufsize, LPCWSTR filename)
1577 {
1578     LPSTR sectionA  = HEAP_strdupWtoA( GetProcessHeap(), 0, section );
1579     LPSTR keyA      = HEAP_strdupWtoA( GetProcessHeap(), 0, key);
1580     LPSTR filenameA = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
1581     INT ret = WritePrivateProfileStructA( sectionA, keyA, buf, bufsize,
1582                                           filenameA );
1583     HeapFree( GetProcessHeap(), 0, sectionA );
1584     HeapFree( GetProcessHeap(), 0, keyA );
1585     HeapFree( GetProcessHeap(), 0, filenameA );
1586
1587     return ret;
1588 }
1589
1590
1591 /***********************************************************************
1592  *           WriteOutProfiles   (KERNEL.315)
1593  */
1594 void WINAPI WriteOutProfiles16(void)
1595 {
1596     EnterCriticalSection( &PROFILE_CritSect );
1597     PROFILE_FlushFile();
1598     LeaveCriticalSection( &PROFILE_CritSect );
1599 }
1600
1601 /***********************************************************************
1602  *           CloseProfileUserMapping   (KERNEL.138)
1603  */
1604 BOOL WINAPI CloseProfileUserMapping(void) {
1605     FIXME("(), stub!\n");
1606     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1607     return FALSE;
1608 }