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