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