dlls/kernel32/profile.c

   1 /*
   2  * Profile functions
   3  *
   4  * Copyright 1993 Miguel de Icaza
   5  * Copyright 1996 Alexandre Julliard
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <string.h>
  26 #include <stdarg.h>
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winnls.h"
  31 #include "winerror.h"
  32 #include "winternl.h"
  33 #include "wine/unicode.h"
  34 #include "wine/library.h"
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(profile);
  38
  39 static const char bom_utf8[] = {0xEF,0xBB,0xBF};
  40
  41 typedef enum
  42 {
  43     ENCODING_ANSI = 1,
  44     ENCODING_UTF8,
  45     ENCODING_UTF16LE,
  46     ENCODING_UTF16BE
  47 } ENCODING;
  48
  49 typedef struct tagPROFILEKEY
  50 {
  51     WCHAR                 *value;
  52     struct tagPROFILEKEY  *next;
  53     WCHAR                  name[1];
  54 } PROFILEKEY;
  55
  56 typedef struct tagPROFILESECTION
  57 {
  58     struct tagPROFILEKEY       *key;
  59     struct tagPROFILESECTION   *next;
  60     WCHAR                       name[1];
  61 } PROFILESECTION;
  62
  63
  64 typedef struct
  65 {
  66     BOOL             changed;
  67     PROFILESECTION  *section;
  68     WCHAR           *filename;
  69     FILETIME LastWriteTime;
  70     ENCODING encoding;
  71 } PROFILE;
  72
  73
  74 #define N_CACHED_PROFILES 10
  75
  76 /* Cached profile files */
  77 static PROFILE *MRUProfile[N_CACHED_PROFILES]={NULL};
  78
  79 #define CurProfile (MRUProfile[0])
  80
  81 /* Check for comments in profile */
  82 #define IS_ENTRY_COMMENT(str)  ((str)[0] == ';')
  83
  84 static const WCHAR emptystringW[] = {0};
  85 static const WCHAR wininiW[] = { 'w','i','n','.','i','n','i',0 };
  86
  87 static CRITICAL_SECTION PROFILE_CritSect;
  88 static CRITICAL_SECTION_DEBUG critsect_debug =
  89 {
  90     0, 0, &PROFILE_CritSect,
  91     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  92       0, 0, { (DWORD_PTR)(__FILE__ ": PROFILE_CritSect") }
  93 };
  94 static CRITICAL_SECTION PROFILE_CritSect = { &critsect_debug, -1, 0, 0, 0, 0 };
  95
  96 static const char hex[16] = "0123456789ABCDEF";
  97
  98 /***********************************************************************
  99  *           PROFILE_CopyEntry
 100  *
 101  * Copy the content of an entry into a buffer, removing quotes, and possibly
 102  * translating environment variables.
 103  */
 104 static void PROFILE_CopyEntry( LPWSTR buffer, LPCWSTR value, int len,
 105                                BOOL strip_quote )
 106 {
 107     WCHAR quote = '\0';
 108
 109     if(!buffer) return;
 110
 111     if (strip_quote && ((*value == '\'') || (*value == '\"')))
 112     {
 113         if (value[1] && (value[strlenW(value)-1] == *value)) quote = *value++;
 114     }
 115
 116     lstrcpynW( buffer, value, len );
 117     if (quote && (len >= lstrlenW(value))) buffer[strlenW(buffer)-1] = '\0';
 118 }
 119
 120 /* byte-swaps shorts in-place in a buffer. len is in WCHARs */
 121 static inline void PROFILE_ByteSwapShortBuffer(WCHAR * buffer, int len)
 122 {
 123     int i;
 124     USHORT * shortbuffer = buffer;
 125     for (i = 0; i < len; i++)
 126         shortbuffer[i] = RtlUshortByteSwap(shortbuffer[i]);
 127 }
 128
 129 /* writes any necessary encoding marker to the file */
 130 static inline void PROFILE_WriteMarker(HANDLE hFile, ENCODING encoding)
 131 {
 132     DWORD dwBytesWritten;
 133     WCHAR bom;
 134     switch (encoding)
 135     {
 136     case ENCODING_ANSI:
 137         break;
 138     case ENCODING_UTF8:
 139         WriteFile(hFile, bom_utf8, sizeof(bom_utf8), &dwBytesWritten, NULL);
 140         break;
 141     case ENCODING_UTF16LE:
 142         bom = 0xFEFF;
 143         WriteFile(hFile, &bom, sizeof(bom), &dwBytesWritten, NULL);
 144         break;
 145     case ENCODING_UTF16BE:
 146         bom = 0xFFFE;
 147         WriteFile(hFile, &bom, sizeof(bom), &dwBytesWritten, NULL);
 148         break;
 149     }
 150 }
 151
 152 static void PROFILE_WriteLine( HANDLE hFile, WCHAR * szLine, int len, ENCODING encoding)
 153 {
 154     char * write_buffer;
 155     int write_buffer_len;
 156     DWORD dwBytesWritten;
 157
 158     TRACE("writing: %s\n", debugstr_wn(szLine, len));
 159
 160     switch (encoding)
 161     {
 162     case ENCODING_ANSI:
 163         write_buffer_len = WideCharToMultiByte(CP_ACP, 0, szLine, len, NULL, 0, NULL, NULL);
 164         write_buffer = HeapAlloc(GetProcessHeap(), 0, write_buffer_len);
 165         if (!write_buffer) return;
 166         len = WideCharToMultiByte(CP_ACP, 0, szLine, len, write_buffer, write_buffer_len, NULL, NULL);
 167         WriteFile(hFile, write_buffer, len, &dwBytesWritten, NULL);
 168         HeapFree(GetProcessHeap(), 0, write_buffer);
 169         break;
 170     case ENCODING_UTF8:
 171         write_buffer_len = WideCharToMultiByte(CP_UTF8, 0, szLine, len, NULL, 0, NULL, NULL);
 172         write_buffer = HeapAlloc(GetProcessHeap(), 0, write_buffer_len);
 173         if (!write_buffer) return;
 174         len = WideCharToMultiByte(CP_UTF8, 0, szLine, len, write_buffer, write_buffer_len, NULL, NULL);
 175         WriteFile(hFile, write_buffer, len, &dwBytesWritten, NULL);
 176         HeapFree(GetProcessHeap(), 0, write_buffer);
 177         break;
 178     case ENCODING_UTF16LE:
 179         WriteFile(hFile, szLine, len * sizeof(WCHAR), &dwBytesWritten, NULL);
 180         break;
 181     case ENCODING_UTF16BE:
 182         PROFILE_ByteSwapShortBuffer(szLine, len);
 183         WriteFile(hFile, szLine, len * sizeof(WCHAR), &dwBytesWritten, NULL);
 184         break;
 185     default:
 186         FIXME("encoding type %d not implemented\n", encoding);
 187     }
 188 }
 189
 190 /***********************************************************************
 191  *           PROFILE_Save
 192  *
 193  * Save a profile tree to a file.
 194  */
 195 static void PROFILE_Save( HANDLE hFile, const PROFILESECTION *section, ENCODING encoding )
 196 {
 197     PROFILEKEY *key;
 198     WCHAR *buffer, *p;
 199
 200     PROFILE_WriteMarker(hFile, encoding);
 201
 202     for ( ; section; section = section->next)
 203     {
 204         int len = 0;
 205
 206         if (section->name[0]) len += strlenW(section->name) + 4;
 207
 208         for (key = section->key; key; key = key->next)
 209         {
 210             len += strlenW(key->name) + 2;
 211             if (key->value) len += strlenW(key->value) + 1;
 212         }
 213
 214         buffer = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 215         if (!buffer) return;
 216
 217         p = buffer;
 218         if (section->name[0])
 219         {
 220             *p++ = '[';
 221             strcpyW( p, section->name );
 222             p += strlenW(p);
 223             *p++ = ']';
 224             *p++ = '\r';
 225             *p++ = '\n';
 226         }
 227
 228         for (key = section->key; key; key = key->next)
 229         {
 230             strcpyW( p, key->name );
 231             p += strlenW(p);
 232             if (key->value)
 233             {
 234                 *p++ = '=';
 235                 strcpyW( p, key->value );
 236                 p += strlenW(p);
 237             }
 238             *p++ = '\r';
 239             *p++ = '\n';
 240         }
 241         PROFILE_WriteLine( hFile, buffer, len, encoding );
 242         HeapFree(GetProcessHeap(), 0, buffer);
 243     }
 244 }
 245
 246
 247 /***********************************************************************
 248  *           PROFILE_Free
 249  *
 250  * Free a profile tree.
 251  */
 252 static void PROFILE_Free( PROFILESECTION *section )
 253 {
 254     PROFILESECTION *next_section;
 255     PROFILEKEY *key, *next_key;
 256
 257     for ( ; section; section = next_section)
 258     {
 259         for (key = section->key; key; key = next_key)
 260         {
 261             next_key = key->next;
 262             HeapFree( GetProcessHeap(), 0, key->value );
 263             HeapFree( GetProcessHeap(), 0, key );
 264         }
 265         next_section = section->next;
 266         HeapFree( GetProcessHeap(), 0, section );
 267     }
 268 }
 269
 270 /* returns TRUE if a whitespace character, else FALSE */
 271 static inline BOOL PROFILE_isspaceW(WCHAR c)
 272 {
 273     /* ^Z (DOS EOF) is a space too  (found on CD-ROMs) */
 274     return (c >= 0x09 && c <= 0x0d) || c == 0x1a || c == 0x20;
 275 }
 276
 277 static inline ENCODING PROFILE_DetectTextEncoding(const void * buffer, int * len)
 278 {
 279     int flags = IS_TEXT_UNICODE_SIGNATURE |
 280                 IS_TEXT_UNICODE_REVERSE_SIGNATURE |
 281                 IS_TEXT_UNICODE_ODD_LENGTH;
 282     if (*len >= sizeof(bom_utf8) && !memcmp(buffer, bom_utf8, sizeof(bom_utf8)))
 283     {
 284         *len = sizeof(bom_utf8);
 285         return ENCODING_UTF8;
 286     }
 287     RtlIsTextUnicode(buffer, *len, &flags);
 288     if (flags & IS_TEXT_UNICODE_SIGNATURE)
 289     {
 290         *len = sizeof(WCHAR);
 291         return ENCODING_UTF16LE;
 292     }
 293     if (flags & IS_TEXT_UNICODE_REVERSE_SIGNATURE)
 294     {
 295         *len = sizeof(WCHAR);
 296         return ENCODING_UTF16BE;
 297     }
 298     *len = 0;
 299     return ENCODING_ANSI;
 300 }
 301
 302
 303 /***********************************************************************
 304  *           PROFILE_Load
 305  *
 306  * Load a profile tree from a file.
 307  */
 308 static PROFILESECTION *PROFILE_Load(HANDLE hFile, ENCODING * pEncoding)
 309 {
 310     void *buffer_base, *pBuffer;
 311     WCHAR * szFile;
 312     const WCHAR *szLineStart, *szLineEnd;
 313     const WCHAR *szValueStart, *szEnd, *next_line;
 314     int len;
 315     PROFILESECTION *section, *first_section;
 316     PROFILESECTION **next_section;
 317     PROFILEKEY *key, *prev_key, **next_key;
 318     DWORD dwFileSize;
 319
 320     TRACE("%p\n", hFile);
 321
 322     dwFileSize = GetFileSize(hFile, NULL);
 323     if (dwFileSize == INVALID_FILE_SIZE || dwFileSize == 0)
 324         return NULL;
 325
 326     buffer_base = HeapAlloc(GetProcessHeap(), 0 , dwFileSize);
 327     if (!buffer_base) return NULL;
 328
 329     if (!ReadFile(hFile, buffer_base, dwFileSize, &dwFileSize, NULL))
 330     {
 331         HeapFree(GetProcessHeap(), 0, buffer_base);
 332         WARN("Error %d reading file\n", GetLastError());
 333         return NULL;
 334     }
 335     len = dwFileSize;
 336     *pEncoding = PROFILE_DetectTextEncoding(buffer_base, &len);
 337     /* len is set to the number of bytes in the character marker.
 338      * we want to skip these bytes */
 339     pBuffer = (char *)buffer_base + len;
 340     dwFileSize -= len;
 341     switch (*pEncoding)
 342     {
 343     case ENCODING_ANSI:
 344         TRACE("ANSI encoding\n");
 345
 346         len = MultiByteToWideChar(CP_ACP, 0, pBuffer, dwFileSize, NULL, 0);
 347         szFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 348         if (!szFile)
 349         {
 350             HeapFree(GetProcessHeap(), 0, buffer_base);
 351             return NULL;
 352         }
 353         MultiByteToWideChar(CP_ACP, 0, pBuffer, dwFileSize, szFile, len);
 354         szEnd = szFile + len;
 355         break;
 356     case ENCODING_UTF8:
 357         TRACE("UTF8 encoding\n");
 358
 359         len = MultiByteToWideChar(CP_UTF8, 0, pBuffer, dwFileSize, NULL, 0);
 360         szFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 361         if (!szFile)
 362         {
 363             HeapFree(GetProcessHeap(), 0, buffer_base);
 364             return NULL;
 365         }
 366         MultiByteToWideChar(CP_UTF8, 0, pBuffer, dwFileSize, szFile, len);
 367         szEnd = szFile + len;
 368         break;
 369     case ENCODING_UTF16LE:
 370         TRACE("UTF16 Little Endian encoding\n");
 371         szFile = pBuffer;
 372         szEnd = (WCHAR *)((char *)pBuffer + dwFileSize);
 373         break;
 374     case ENCODING_UTF16BE:
 375         TRACE("UTF16 Big Endian encoding\n");
 376         szFile = pBuffer;
 377         szEnd = (WCHAR *)((char *)pBuffer + dwFileSize);
 378         PROFILE_ByteSwapShortBuffer(szFile, dwFileSize / sizeof(WCHAR));
 379         break;
 380     default:
 381         FIXME("encoding type %d not implemented\n", *pEncoding);
 382         HeapFree(GetProcessHeap(), 0, buffer_base);
 383         return NULL;
 384     }
 385
 386     first_section = HeapAlloc( GetProcessHeap(), 0, sizeof(*section) );
 387     if(first_section == NULL)
 388     {
 389         if (szFile != pBuffer)
 390             HeapFree(GetProcessHeap(), 0, szFile);
 391         HeapFree(GetProcessHeap(), 0, buffer_base);
 392         return NULL;
 393     }
 394     first_section->name[0] = 0;
 395     first_section->key  = NULL;
 396     first_section->next = NULL;
 397     next_section = &first_section->next;
 398     next_key     = &first_section->key;
 399     prev_key     = NULL;
 400     next_line    = szFile;
 401
 402     while (next_line < szEnd)
 403     {
 404         szLineStart = next_line;
 405         while (next_line < szEnd && *next_line != '\n' && *next_line != '\r') next_line++;
 406         while (next_line < szEnd && (*next_line == '\n' || *next_line == '\r')) next_line++;
 407         szLineEnd = next_line;
 408
 409         /* get rid of white space */
 410         while (szLineStart < szLineEnd && PROFILE_isspaceW(*szLineStart)) szLineStart++;
 411         while ((szLineEnd > szLineStart) && PROFILE_isspaceW(szLineEnd[-1])) szLineEnd--;
 412
 413         if (szLineStart >= szLineEnd) continue;
 414
 415         if (*szLineStart == '[')  /* section start */
 416         {
 417             for (len = szLineEnd - szLineStart; len > 0; len--) if (szLineStart[len - 1] == ']') break;
 418             if (!len)
 419             {
 420                 WARN("Invalid section header: %s\n",
 421                     debugstr_wn(szLineStart, (int)(szLineEnd - szLineStart)) );
 422             }
 423             else
 424             {
 425                 szLineStart++;
 426                 len -= 2;
 427                 /* no need to allocate +1 for NULL terminating character as
 428                  * already included in structure */
 429                 if (!(section = HeapAlloc( GetProcessHeap(), 0, sizeof(*section) + len * sizeof(WCHAR) )))
 430                     break;
 431                 memcpy(section->name, szLineStart, len * sizeof(WCHAR));
 432                 section->name[len] = '\0';
 433                 section->key  = NULL;
 434                 section->next = NULL;
 435                 *next_section = section;
 436                 next_section  = &section->next;
 437                 next_key      = &section->key;
 438                 prev_key      = NULL;
 439
 440                 TRACE("New section: %s\n", debugstr_w(section->name));
 441
 442                 continue;
 443             }
 444         }
 445
 446         /* get rid of white space after the name and before the start
 447          * of the value */
 448         len = szLineEnd - szLineStart;
 449         for (szValueStart = szLineStart; szValueStart < szLineEnd; szValueStart++) if (*szValueStart == '=') break;
 450         if (szValueStart < szLineEnd)
 451         {
 452             const WCHAR *szNameEnd = szValueStart;
 453             while ((szNameEnd > szLineStart) && PROFILE_isspaceW(szNameEnd[-1])) szNameEnd--;
 454             len = szNameEnd - szLineStart;
 455             szValueStart++;
 456             while (szValueStart < szLineEnd && PROFILE_isspaceW(*szValueStart)) szValueStart++;
 457         }
 458         else szValueStart = NULL;
 459
 460         if (len || !prev_key || *prev_key->name)
 461         {
 462             /* no need to allocate +1 for NULL terminating character as
 463              * already included in structure */
 464             if (!(key = HeapAlloc( GetProcessHeap(), 0, sizeof(*key) + len * sizeof(WCHAR) ))) break;
 465             memcpy(key->name, szLineStart, len * sizeof(WCHAR));
 466             key->name[len] = '\0';
 467             if (szValueStart)
 468             {
 469                 len = (int)(szLineEnd - szValueStart);
 470                 key->value = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) );
 471                 memcpy(key->value, szValueStart, len * sizeof(WCHAR));
 472                 key->value[len] = '\0';
 473             }
 474             else key->value = NULL;
 475
 476            key->next  = NULL;
 477            *next_key  = key;
 478            next_key   = &key->next;
 479            prev_key   = key;
 480
 481            TRACE("New key: name=%s, value=%s\n",
 482                debugstr_w(key->name), key->value ? debugstr_w(key->value) : "(none)");
 483         }
 484     }
 485     if (szFile != pBuffer)
 486         HeapFree(GetProcessHeap(), 0, szFile);
 487     HeapFree(GetProcessHeap(), 0, buffer_base);
 488     return first_section;
 489 }
 490
 491
 492 /***********************************************************************
 493  *           PROFILE_DeleteSection
 494  *
 495  * Delete a section from a profile tree.
 496  */
 497 static BOOL PROFILE_DeleteSection( PROFILESECTION **section, LPCWSTR name )
 498 {
 499     while (*section)
 500     {
 501         if (!strcmpiW( (*section)->name, name ))
 502         {
 503             PROFILESECTION *to_del = *section;
 504             *section = to_del->next;
 505             to_del->next = NULL;
 506             PROFILE_Free( to_del );
 507             return TRUE;
 508         }
 509         section = &(*section)->next;
 510     }
 511     return FALSE;
 512 }
 513
 514
 515 /***********************************************************************
 516  *           PROFILE_DeleteKey
 517  *
 518  * Delete a key from a profile tree.
 519  */
 520 static BOOL PROFILE_DeleteKey( PROFILESECTION **section,
 521                                LPCWSTR section_name, LPCWSTR key_name )
 522 {
 523     while (*section)
 524     {
 525         if (!strcmpiW( (*section)->name, section_name ))
 526         {
 527             PROFILEKEY **key = &(*section)->key;
 528             while (*key)
 529             {
 530                 if (!strcmpiW( (*key)->name, key_name ))
 531                 {
 532                     PROFILEKEY *to_del = *key;
 533                     *key = to_del->next;
 534                     HeapFree( GetProcessHeap(), 0, to_del->value);
 535                     HeapFree( GetProcessHeap(), 0, to_del );
 536                     return TRUE;
 537                 }
 538                 key = &(*key)->next;
 539             }
 540         }
 541         section = &(*section)->next;
 542     }
 543     return FALSE;
 544 }
 545
 546
 547 /***********************************************************************
 548  *           PROFILE_DeleteAllKeys
 549  *
 550  * Delete all keys from a profile tree.
 551  */
 552 static void PROFILE_DeleteAllKeys( LPCWSTR section_name)
 553 {
 554     PROFILESECTION **section= &CurProfile->section;
 555     while (*section)
 556     {
 557         if (!strcmpiW( (*section)->name, section_name ))
 558         {
 559             PROFILEKEY **key = &(*section)->key;
 560             while (*key)
 561             {
 562                 PROFILEKEY *to_del = *key;
 563                 *key = to_del->next;
 564                 HeapFree( GetProcessHeap(), 0, to_del->value);
 565                 HeapFree( GetProcessHeap(), 0, to_del );
 566                 CurProfile->changed =TRUE;
 567             }
 568         }
 569         section = &(*section)->next;
 570     }
 571 }
 572
 573
 574 /***********************************************************************
 575  *           PROFILE_Find
 576  *
 577  * Find a key in a profile tree, optionally creating it.
 578  */
 579 static PROFILEKEY *PROFILE_Find( PROFILESECTION **section, LPCWSTR section_name,
 580                                  LPCWSTR key_name, BOOL create, BOOL create_always )
 581 {
 582     LPCWSTR p;
 583     int seclen = 0, keylen = 0;
 584
 585     while (PROFILE_isspaceW(*section_name)) section_name++;
 586     if (*section_name)
 587     {
 588         p = section_name + strlenW(section_name) - 1;
 589         while ((p > section_name) && PROFILE_isspaceW(*p)) p--;
 590         seclen = p - section_name + 1;
 591     }
 592
 593     while (PROFILE_isspaceW(*key_name)) key_name++;
 594     if (*key_name)
 595     {
 596         p = key_name + strlenW(key_name) - 1;
 597         while ((p > key_name) && PROFILE_isspaceW(*p)) p--;
 598         keylen = p - key_name + 1;
 599     }
 600
 601     while (*section)
 602     {
 603         if (!strncmpiW((*section)->name, section_name, seclen) &&
 604             ((*section)->name)[seclen] == '\0')
 605         {
 606             PROFILEKEY **key = &(*section)->key;
 607
 608             while (*key)
 609             {
 610                 /* If create_always is FALSE then we check if the keyname
 611                  * already exists. Otherwise we add it regardless of its
 612                  * existence, to allow keys to be added more than once in
 613                  * some cases.
 614                  */
 615                 if(!create_always)
 616                 {
 617                     if ( (!(strncmpiW( (*key)->name, key_name, keylen )))
 618                          && (((*key)->name)[keylen] == '\0') )
 619                         return *key;
 620                 }
 621                 key = &(*key)->next;
 622             }
 623             if (!create) return NULL;
 624             if (!(*key = HeapAlloc( GetProcessHeap(), 0, sizeof(PROFILEKEY) + strlenW(key_name) * sizeof(WCHAR) )))
 625                 return NULL;
 626             strcpyW( (*key)->name, key_name );
 627             (*key)->value = NULL;
 628             (*key)->next  = NULL;
 629             return *key;
 630         }
 631         section = &(*section)->next;
 632     }
 633     if (!create) return NULL;
 634     *section = HeapAlloc( GetProcessHeap(), 0, sizeof(PROFILESECTION) + strlenW(section_name) * sizeof(WCHAR) );
 635     if(*section == NULL) return NULL;
 636     strcpyW( (*section)->name, section_name );
 637     (*section)->next = NULL;
 638     if (!((*section)->key  = HeapAlloc( GetProcessHeap(), 0,
 639                                         sizeof(PROFILEKEY) + strlenW(key_name) * sizeof(WCHAR) )))
 640     {
 641         HeapFree(GetProcessHeap(), 0, *section);
 642         return NULL;
 643     }
 644     strcpyW( (*section)->key->name, key_name );
 645     (*section)->key->value = NULL;
 646     (*section)->key->next  = NULL;
 647     return (*section)->key;
 648 }
 649
 650
 651 /***********************************************************************
 652  *           PROFILE_FlushFile
 653  *
 654  * Flush the current profile to disk if changed.
 655  */
 656 static BOOL PROFILE_FlushFile(void)
 657 {
 658     HANDLE hFile = NULL;
 659     FILETIME LastWriteTime;
 660
 661     if(!CurProfile)
 662     {
 663         WARN("No current profile!\n");
 664         return FALSE;
 665     }
 666
 667     if (!CurProfile->changed) return TRUE;
 668
 669     hFile = CreateFileW(CurProfile->filename, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
 670                         NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 671
 672     if (hFile == INVALID_HANDLE_VALUE)
 673     {
 674         WARN("could not save profile file %s (error was %d)\n", debugstr_w(CurProfile->filename), GetLastError());
 675         return FALSE;
 676     }
 677
 678     TRACE("Saving %s\n", debugstr_w(CurProfile->filename));
 679     PROFILE_Save( hFile, CurProfile->section, CurProfile->encoding );
 680     if(GetFileTime(hFile, NULL, NULL, &LastWriteTime))
 681        CurProfile->LastWriteTime=LastWriteTime;
 682     CloseHandle( hFile );
 683     CurProfile->changed = FALSE;
 684     return TRUE;
 685 }
 686
 687
 688 /***********************************************************************
 689  *           PROFILE_ReleaseFile
 690  *
 691  * Flush the current profile to disk and remove it from the cache.
 692  */
 693 static void PROFILE_ReleaseFile(void)
 694 {
 695     PROFILE_FlushFile();
 696     PROFILE_Free( CurProfile->section );
 697     HeapFree( GetProcessHeap(), 0, CurProfile->filename );
 698     CurProfile->changed = FALSE;
 699     CurProfile->section = NULL;
 700     CurProfile->filename  = NULL;
 701     CurProfile->encoding = ENCODING_ANSI;
 702     ZeroMemory(&CurProfile->LastWriteTime, sizeof(CurProfile->LastWriteTime));
 703 }
 704
 705 /***********************************************************************
 706  *
 707  * Compares a file time with the current time. If the file time is
 708  * at least 2.1 seconds in the past, return true.
 709  *
 710  * Intended as cache safety measure: The time resolution on FAT is
 711  * two seconds, so files that are not at least two seconds old might
 712  * keep their time even on modification, so don't cache them.
 713  */
 714 static BOOL is_not_current(FILETIME *ft)
 715 {
 716     LARGE_INTEGER now;
 717     LONGLONG ftll;
 718
 719     NtQuerySystemTime( &now );
 720     ftll = ((LONGLONG)ft->dwHighDateTime << 32) + ft->dwLowDateTime;
 721     TRACE("%s; %s\n", wine_dbgstr_longlong(ftll), wine_dbgstr_longlong(now.QuadPart));
 722     return ftll + 21000000 < now.QuadPart;
 723 }
 724
 725 /***********************************************************************
 726  *           PROFILE_Open
 727  *
 728  * Open a profile file, checking the cached file first.
 729  */
 730 static BOOL PROFILE_Open( LPCWSTR filename, BOOL write_access )
 731 {
 732     WCHAR buffer[MAX_PATH];
 733     HANDLE hFile = INVALID_HANDLE_VALUE;
 734     FILETIME LastWriteTime;
 735     int i,j;
 736     PROFILE *tempProfile;
 737
 738     ZeroMemory(&LastWriteTime, sizeof(LastWriteTime));
 739
 740     /* First time around */
 741
 742     if(!CurProfile)
 743        for(i=0;i<N_CACHED_PROFILES;i++)
 744        {
 745           MRUProfile[i]=HeapAlloc( GetProcessHeap(), 0, sizeof(PROFILE) );
 746           if(MRUProfile[i] == NULL) break;
 747           MRUProfile[i]->changed=FALSE;
 748           MRUProfile[i]->section=NULL;
 749           MRUProfile[i]->filename=NULL;
 750           MRUProfile[i]->encoding=ENCODING_ANSI;
 751           ZeroMemory(&MRUProfile[i]->LastWriteTime, sizeof(FILETIME));
 752        }
 753
 754     if (!filename)
 755         filename = wininiW;
 756
 757     if ((RtlDetermineDosPathNameType_U(filename) == RELATIVE_PATH) &&
 758         !strchrW(filename, '\\') && !strchrW(filename, '/'))
 759     {
 760         static const WCHAR wszSeparator[] = {'\\', 0};
 761         WCHAR windirW[MAX_PATH];
 762         GetWindowsDirectoryW( windirW, MAX_PATH );
 763         strcpyW(buffer, windirW);
 764         strcatW(buffer, wszSeparator);
 765         strcatW(buffer, filename);
 766     }
 767     else
 768     {
 769         LPWSTR dummy;
 770         GetFullPathNameW(filename, ARRAY_SIZE(buffer), buffer, &dummy);
 771     }
 772
 773     TRACE("path: %s\n", debugstr_w(buffer));
 774
 775     hFile = CreateFileW(buffer, GENERIC_READ | (write_access ? GENERIC_WRITE : 0),
 776                         FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
 777                         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 778
 779     if ((hFile == INVALID_HANDLE_VALUE) && (GetLastError() != ERROR_FILE_NOT_FOUND))
 780     {
 781         WARN("Error %d opening file %s\n", GetLastError(), debugstr_w(buffer));
 782         return FALSE;
 783     }
 784
 785     for(i=0;i<N_CACHED_PROFILES;i++)
 786     {
 787         if ((MRUProfile[i]->filename && !strcmpiW( buffer, MRUProfile[i]->filename )))
 788         {
 789             TRACE("MRU Filename: %s, new filename: %s\n", debugstr_w(MRUProfile[i]->filename), debugstr_w(buffer));
 790             if(i)
 791             {
 792                 PROFILE_FlushFile();
 793                 tempProfile=MRUProfile[i];
 794                 for(j=i;j>0;j--)
 795                     MRUProfile[j]=MRUProfile[j-1];
 796                 CurProfile=tempProfile;
 797             }
 798
 799             if (hFile != INVALID_HANDLE_VALUE)
 800             {
 801                 GetFileTime(hFile, NULL, NULL, &LastWriteTime);
 802                 if (!memcmp( &CurProfile->LastWriteTime, &LastWriteTime, sizeof(FILETIME) ) &&
 803                     is_not_current(&LastWriteTime))
 804                     TRACE("(%s): already opened (mru=%d)\n",
 805                           debugstr_w(buffer), i);
 806                 else
 807                 {
 808                     TRACE("(%s): already opened, needs refreshing (mru=%d)\n",
 809                           debugstr_w(buffer), i);
 810                     PROFILE_Free(CurProfile->section);
 811                     CurProfile->section = PROFILE_Load(hFile, &CurProfile->encoding);
 812                     CurProfile->LastWriteTime = LastWriteTime;
 813                 }
 814                 CloseHandle(hFile);
 815                 return TRUE;
 816             }
 817             else TRACE("(%s): already opened, not yet created (mru=%d)\n",
 818                        debugstr_w(buffer), i);
 819         }
 820     }
 821
 822     /* Flush the old current profile */
 823     PROFILE_FlushFile();
 824
 825     /* Make the oldest profile the current one only in order to get rid of it */
 826     if(i==N_CACHED_PROFILES)
 827       {
 828        tempProfile=MRUProfile[N_CACHED_PROFILES-1];
 829        for(i=N_CACHED_PROFILES-1;i>0;i--)
 830           MRUProfile[i]=MRUProfile[i-1];
 831        CurProfile=tempProfile;
 832       }
 833     if(CurProfile->filename) PROFILE_ReleaseFile();
 834
 835     /* OK, now that CurProfile is definitely free we assign it our new file */
 836     CurProfile->filename  = HeapAlloc( GetProcessHeap(), 0, (strlenW(buffer)+1) * sizeof(WCHAR) );
 837     strcpyW( CurProfile->filename, buffer );
 838
 839     if (hFile != INVALID_HANDLE_VALUE)
 840     {
 841         CurProfile->section = PROFILE_Load(hFile, &CurProfile->encoding);
 842         GetFileTime(hFile, NULL, NULL, &CurProfile->LastWriteTime);
 843         CloseHandle(hFile);
 844     }
 845     else
 846     {
 847         /* Does not exist yet, we will create it in PROFILE_FlushFile */
 848         WARN("profile file %s not found\n", debugstr_w(buffer) );
 849     }
 850     return TRUE;
 851 }
 852
 853
 854 /***********************************************************************
 855  *           PROFILE_GetSection
 856  *
 857  * Returns all keys of a section.
 858  * If return_values is TRUE, also include the corresponding values.
 859  */
 860 static INT PROFILE_GetSection( PROFILESECTION *section, LPCWSTR section_name,
 861                                LPWSTR buffer, UINT len, BOOL return_values )
 862 {
 863     PROFILEKEY *key;
 864
 865     if(!buffer) return 0;
 866
 867     TRACE("%s,%p,%u\n", debugstr_w(section_name), buffer, len);
 868
 869     while (section)
 870     {
 871         if (!strcmpiW( section->name, section_name ))
 872         {
 873             UINT oldlen = len;
 874             for (key = section->key; key; key = key->next)
 875             {
 876                 if (len <= 2) break;
 877                 if (!*key->name && !key->value) continue;  /* Skip empty lines */
 878                 if (IS_ENTRY_COMMENT(key->name)) continue;  /* Skip comments */
 879                 if (!return_values && !key->value) continue;  /* Skip lines w.o. '=' */
 880                 PROFILE_CopyEntry( buffer, key->name, len - 1, 0 );
 881                 len -= strlenW(buffer) + 1;
 882                 buffer += strlenW(buffer) + 1;
 883                 if (len < 2)
 884                     break;
 885                 if (return_values && key->value) {
 886                         buffer[-1] = '=';
 887                         PROFILE_CopyEntry ( buffer, key->value, len - 1, 0 );
 888                         len -= strlenW(buffer) + 1;
 889                         buffer += strlenW(buffer) + 1;
 890                 }
 891             }
 892             *buffer = '\0';
 893             if (len <= 1)
 894                 /*If either lpszSection or lpszKey is NULL and the supplied
 895                   destination buffer is too small to hold all the strings,
 896                   the last string is truncated and followed by two null characters.
 897                   In this case, the return value is equal to cchReturnBuffer
 898                   minus two. */
 899             {
 900                 buffer[-1] = '\0';
 901                 return oldlen - 2;
 902             }
 903             return oldlen - len;
 904         }
 905         section = section->next;
 906     }
 907     buffer[0] = buffer[1] = '\0';
 908     return 0;
 909 }
 910
 911 /* See GetPrivateProfileSectionNamesA for documentation */
 912 static INT PROFILE_GetSectionNames( LPWSTR buffer, UINT len )
 913 {
 914     LPWSTR buf;
 915     UINT buflen,tmplen;
 916     PROFILESECTION *section;
 917
 918     TRACE("(%p, %d)\n", buffer, len);
 919
 920     if (!buffer || !len)
 921         return 0;
 922     if (len==1) {
 923         *buffer='\0';
 924         return 0;
 925     }
 926
 927     buflen=len-1;
 928     buf=buffer;
 929     section = CurProfile->section;
 930     while ((section!=NULL)) {
 931         if (section->name[0]) {
 932             tmplen = strlenW(section->name)+1;
 933             if (tmplen >= buflen) {
 934                 if (buflen > 0) {
 935                     memcpy(buf, section->name, (buflen-1) * sizeof(WCHAR));
 936                     buf += buflen-1;
 937                     *buf++='\0';
 938                 }
 939                 *buf='\0';
 940                 return len-2;
 941             }
 942             memcpy(buf, section->name, tmplen * sizeof(WCHAR));
 943             buf += tmplen;
 944             buflen -= tmplen;
 945         }
 946         section = section->next;
 947     }
 948     *buf='\0';
 949     return buf-buffer;
 950 }
 951
 952
 953 /***********************************************************************
 954  *           PROFILE_GetString
 955  *
 956  * Get a profile string.
 957  *
 958  * Tests with GetPrivateProfileString16, W95a,
 959  * with filled buffer ("****...") and section "set1" and key_name "1" valid:
 960  * section      key_name        def_val         res     buffer
 961  * "set1"       "1"             "x"             43      [data]
 962  * "set1"       "1   "          "x"             43      [data]          (!)
 963  * "set1"       "  1  "'        "x"             43      [data]          (!)
 964  * "set1"       ""              "x"             1       "x"
 965  * "set1"       ""              "x   "          1       "x"             (!)
 966  * "set1"       ""              "  x   "        3       "  x"           (!)
 967  * "set1"       NULL            "x"             6       "1\02\03\0\0"
 968  * "set1"       ""              "x"             1       "x"
 969  * NULL         "1"             "x"             0       ""              (!)
 970  * ""           "1"             "x"             1       "x"
 971  * NULL         NULL            ""              0       ""
 972  *
 973  *
 974  */
 975 static INT PROFILE_GetString( LPCWSTR section, LPCWSTR key_name,
 976                               LPCWSTR def_val, LPWSTR buffer, UINT len )
 977 {
 978     PROFILEKEY *key = NULL;
 979     static const WCHAR empty_strW[] = { 0 };
 980
 981     if(!buffer || !len) return 0;
 982
 983     if (!def_val) def_val = empty_strW;
 984     if (key_name)
 985     {
 986         key = PROFILE_Find( &CurProfile->section, section, key_name, FALSE, FALSE);
 987         PROFILE_CopyEntry( buffer, (key && key->value) ? key->value : def_val,
 988                            len, TRUE );
 989         TRACE("(%s,%s,%s): returning %s\n",
 990               debugstr_w(section), debugstr_w(key_name),
 991               debugstr_w(def_val), debugstr_w(buffer) );
 992         return strlenW( buffer );
 993     }
 994     /* no "else" here ! */
 995     if (section)
 996     {
 997         INT ret = PROFILE_GetSection(CurProfile->section, section, buffer, len, FALSE);
 998         if (!buffer[0]) /* no luck -> def_val */
 999         {
1000             PROFILE_CopyEntry(buffer, def_val, len, TRUE);
1001             ret = strlenW(buffer);
1002         }
1003         return ret;
1004     }
1005     buffer[0] = '\0';
1006     return 0;
1007 }
1008
1009
1010 /***********************************************************************
1011  *           PROFILE_SetString
1012  *
1013  * Set a profile string.
1014  */
1015 static BOOL PROFILE_SetString( LPCWSTR section_name, LPCWSTR key_name,
1016                                LPCWSTR value, BOOL create_always )
1017 {
1018     if (!key_name)  /* Delete a whole section */
1019     {
1020         TRACE("(%s)\n", debugstr_w(section_name));
1021         CurProfile->changed |= PROFILE_DeleteSection( &CurProfile->section,
1022                                                       section_name );
1023         return TRUE;         /* Even if PROFILE_DeleteSection() has failed,
1024                                 this is not an error on application's level.*/
1025     }
1026     else if (!value)  /* Delete a key */
1027     {
1028         TRACE("(%s,%s)\n", debugstr_w(section_name), debugstr_w(key_name) );
1029         CurProfile->changed |= PROFILE_DeleteKey( &CurProfile->section,
1030                                                   section_name, key_name );
1031         return TRUE;          /* same error handling as above */
1032     }
1033     else  /* Set the key value */
1034     {
1035         PROFILEKEY *key = PROFILE_Find(&CurProfile->section, section_name,
1036                                         key_name, TRUE, create_always );
1037         TRACE("(%s,%s,%s):\n",
1038               debugstr_w(section_name), debugstr_w(key_name), debugstr_w(value) );
1039         if (!key) return FALSE;
1040
1041         /* strip the leading spaces. We can safely strip \n\r and
1042          * friends too, they should not happen here anyway. */
1043         while (PROFILE_isspaceW(*value)) value++;
1044
1045         if (key->value)
1046         {
1047             if (!strcmpW( key->value, value ))
1048             {
1049                 TRACE("  no change needed\n" );
1050                 return TRUE;  /* No change needed */
1051             }
1052             TRACE("  replacing %s\n", debugstr_w(key->value) );
1053             HeapFree( GetProcessHeap(), 0, key->value );
1054         }
1055         else TRACE("  creating key\n" );
1056         key->value = HeapAlloc( GetProcessHeap(), 0, (strlenW(value)+1) * sizeof(WCHAR) );
1057         strcpyW( key->value, value );
1058         CurProfile->changed = TRUE;
1059     }
1060     return TRUE;
1061 }
1062
1063
1064 /********************* API functions **********************************/
1065
1066
1067 /***********************************************************************
1068  *           GetProfileIntA   (KERNEL32.@)
1069  */
1070 UINT WINAPI GetProfileIntA( LPCSTR section, LPCSTR entry, INT def_val )
1071 {
1072     return GetPrivateProfileIntA( section, entry, def_val, "win.ini" );
1073 }
1074
1075 /***********************************************************************
1076  *           GetProfileIntW   (KERNEL32.@)
1077  */
1078 UINT WINAPI GetProfileIntW( LPCWSTR section, LPCWSTR entry, INT def_val )
1079 {
1080     return GetPrivateProfileIntW( section, entry, def_val, wininiW );
1081 }
1082
1083 /***********************************************************************
1084  *           GetPrivateProfileStringW   (KERNEL32.@)
1085  */
1086 INT WINAPI GetPrivateProfileStringW( LPCWSTR section, LPCWSTR entry,
1087                                      LPCWSTR def_val, LPWSTR buffer,
1088                                      UINT len, LPCWSTR filename )
1089 {
1090     int         ret;
1091     LPWSTR      defval_tmp = NULL;
1092
1093     TRACE("%s,%s,%s,%p,%u,%s\n", debugstr_w(section), debugstr_w(entry),
1094           debugstr_w(def_val), buffer, len, debugstr_w(filename));
1095
1096     /* strip any trailing ' ' of def_val. */
1097     if (def_val)
1098     {
1099         LPCWSTR p = def_val + strlenW(def_val) - 1;
1100
1101         while (p > def_val && *p == ' ')
1102             p--;
1103
1104         if (p >= def_val)
1105         {
1106             int vlen = (int)(p - def_val) + 1;
1107
1108             defval_tmp = HeapAlloc(GetProcessHeap(), 0, (vlen + 1) * sizeof(WCHAR));
1109             memcpy(defval_tmp, def_val, vlen * sizeof(WCHAR));
1110             defval_tmp[vlen] = '\0';
1111             def_val = defval_tmp;
1112         }
1113     }
1114
1115     RtlEnterCriticalSection( &PROFILE_CritSect );
1116
1117     if (PROFILE_Open( filename, FALSE )) {
1118         if (section == NULL)
1119             ret = PROFILE_GetSectionNames(buffer, len);
1120         else
1121             /* PROFILE_GetString can handle the 'entry == NULL' case */
1122             ret = PROFILE_GetString( section, entry, def_val, buffer, len );
1123     } else if (buffer && def_val) {
1124        lstrcpynW( buffer, def_val, len );
1125        ret = strlenW( buffer );
1126     }
1127     else
1128        ret = 0;
1129
1130     RtlLeaveCriticalSection( &PROFILE_CritSect );
1131
1132     HeapFree(GetProcessHeap(), 0, defval_tmp);
1133
1134     TRACE("returning %s, %d\n", debugstr_w(buffer), ret);
1135
1136     return ret;
1137 }
1138
1139 /***********************************************************************
1140  *           GetPrivateProfileStringA   (KERNEL32.@)
1141  */
1142 INT WINAPI GetPrivateProfileStringA( LPCSTR section, LPCSTR entry,
1143                                      LPCSTR def_val, LPSTR buffer,
1144                                      UINT len, LPCSTR filename )
1145 {
1146     UNICODE_STRING sectionW, entryW, def_valW, filenameW;
1147     LPWSTR bufferW;
1148     INT retW, ret = 0;
1149
1150     bufferW = buffer ? HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)) : NULL;
1151     if (section) RtlCreateUnicodeStringFromAsciiz(&sectionW, section);
1152     else sectionW.Buffer = NULL;
1153     if (entry) RtlCreateUnicodeStringFromAsciiz(&entryW, entry);
1154     else entryW.Buffer = NULL;
1155     if (def_val) RtlCreateUnicodeStringFromAsciiz(&def_valW, def_val);
1156     else def_valW.Buffer = NULL;
1157     if (filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1158     else filenameW.Buffer = NULL;
1159
1160     retW = GetPrivateProfileStringW( sectionW.Buffer, entryW.Buffer,
1161                                      def_valW.Buffer, bufferW, len,
1162                                      filenameW.Buffer);
1163     if (len && buffer)
1164     {
1165         if (retW)
1166         {
1167             ret = WideCharToMultiByte(CP_ACP, 0, bufferW, retW, buffer, len - 1, NULL, NULL);
1168             if (!ret)
1169                 ret = len - 1;
1170         }
1171         buffer[ret] = 0;
1172     }
1173
1174     RtlFreeUnicodeString(&sectionW);
1175     RtlFreeUnicodeString(&entryW);
1176     RtlFreeUnicodeString(&def_valW);
1177     RtlFreeUnicodeString(&filenameW);
1178     HeapFree(GetProcessHeap(), 0, bufferW);
1179     return ret;
1180 }
1181
1182 /***********************************************************************
1183  *           GetProfileStringA   (KERNEL32.@)
1184  */
1185 INT WINAPI GetProfileStringA( LPCSTR section, LPCSTR entry, LPCSTR def_val,
1186                               LPSTR buffer, UINT len )
1187 {
1188     return GetPrivateProfileStringA( section, entry, def_val,
1189                                      buffer, len, "win.ini" );
1190 }
1191
1192 /***********************************************************************
1193  *           GetProfileStringW   (KERNEL32.@)
1194  */
1195 INT WINAPI GetProfileStringW( LPCWSTR section, LPCWSTR entry,
1196                               LPCWSTR def_val, LPWSTR buffer, UINT len )
1197 {
1198     return GetPrivateProfileStringW( section, entry, def_val,
1199                                      buffer, len, wininiW );
1200 }
1201
1202 /***********************************************************************
1203  *           WriteProfileStringA   (KERNEL32.@)
1204  */
1205 BOOL WINAPI WriteProfileStringA( LPCSTR section, LPCSTR entry,
1206                                  LPCSTR string )
1207 {
1208     return WritePrivateProfileStringA( section, entry, string, "win.ini" );
1209 }
1210
1211 /***********************************************************************
1212  *           WriteProfileStringW   (KERNEL32.@)
1213  */
1214 BOOL WINAPI WriteProfileStringW( LPCWSTR section, LPCWSTR entry,
1215                                      LPCWSTR string )
1216 {
1217     return WritePrivateProfileStringW( section, entry, string, wininiW );
1218 }
1219
1220
1221 /***********************************************************************
1222  *           GetPrivateProfileIntW   (KERNEL32.@)
1223  */
1224 UINT WINAPI GetPrivateProfileIntW( LPCWSTR section, LPCWSTR entry,
1225                                    INT def_val, LPCWSTR filename )
1226 {
1227     WCHAR buffer[30];
1228     UNICODE_STRING bufferW;
1229     ULONG result;
1230
1231     if (GetPrivateProfileStringW( section, entry, emptystringW, buffer, ARRAY_SIZE( buffer ),
1232                                   filename ) == 0)
1233         return def_val;
1234
1235     /* FIXME: if entry can be found but it's empty, then Win16 is
1236      * supposed to return 0 instead of def_val ! Difficult/problematic
1237      * to implement (every other failure also returns zero buffer),
1238      * thus wait until testing framework avail for making sure nothing
1239      * else gets broken that way. */
1240     if (!buffer[0]) return (UINT)def_val;
1241
1242     RtlInitUnicodeString( &bufferW, buffer );
1243     RtlUnicodeStringToInteger( &bufferW, 0, &result);
1244     return result;
1245 }
1246
1247 /***********************************************************************
1248  *           GetPrivateProfileIntA   (KERNEL32.@)
1249  *
1250  * FIXME: rewrite using unicode
1251  */
1252 UINT WINAPI GetPrivateProfileIntA( LPCSTR section, LPCSTR entry,
1253                                    INT def_val, LPCSTR filename )
1254 {
1255     UNICODE_STRING entryW, filenameW, sectionW;
1256     UINT res;
1257     if(entry) RtlCreateUnicodeStringFromAsciiz(&entryW, entry);
1258     else entryW.Buffer = NULL;
1259     if(filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1260     else filenameW.Buffer = NULL;
1261     if(section) RtlCreateUnicodeStringFromAsciiz(&sectionW, section);
1262     else sectionW.Buffer = NULL;
1263     res = GetPrivateProfileIntW(sectionW.Buffer, entryW.Buffer, def_val,
1264                                 filenameW.Buffer);
1265     RtlFreeUnicodeString(&sectionW);
1266     RtlFreeUnicodeString(&filenameW);
1267     RtlFreeUnicodeString(&entryW);
1268     return res;
1269 }
1270
1271 /***********************************************************************
1272  *           GetPrivateProfileSectionW   (KERNEL32.@)
1273  */
1274 INT WINAPI GetPrivateProfileSectionW( LPCWSTR section, LPWSTR buffer,
1275                                       DWORD len, LPCWSTR filename )
1276 {
1277     int ret = 0;
1278
1279     if (!section || !buffer)
1280     {
1281         SetLastError(ERROR_INVALID_PARAMETER);
1282         return 0;
1283     }
1284
1285     TRACE("(%s, %p, %d, %s)\n", debugstr_w(section), buffer, len, debugstr_w(filename));
1286
1287     RtlEnterCriticalSection( &PROFILE_CritSect );
1288
1289     if (PROFILE_Open( filename, FALSE ))
1290         ret = PROFILE_GetSection(CurProfile->section, section, buffer, len, TRUE);
1291
1292     RtlLeaveCriticalSection( &PROFILE_CritSect );
1293
1294     return ret;
1295 }
1296
1297 /***********************************************************************
1298  *           GetPrivateProfileSectionA   (KERNEL32.@)
1299  */
1300 INT WINAPI GetPrivateProfileSectionA( LPCSTR section, LPSTR buffer,
1301                                       DWORD len, LPCSTR filename )
1302 {
1303     UNICODE_STRING sectionW, filenameW;
1304     LPWSTR bufferW;
1305     INT retW, ret = 0;
1306
1307     if (!section || !buffer)
1308     {
1309         SetLastError(ERROR_INVALID_PARAMETER);
1310         return 0;
1311     }
1312
1313     bufferW = HeapAlloc(GetProcessHeap(), 0, len * 2 * sizeof(WCHAR));
1314     RtlCreateUnicodeStringFromAsciiz(&sectionW, section);
1315     if (filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1316     else filenameW.Buffer = NULL;
1317
1318     retW = GetPrivateProfileSectionW(sectionW.Buffer, bufferW, len * 2, filenameW.Buffer);
1319     if (retW)
1320     {
1321         if (retW == len * 2 - 2) retW++;  /* overflow */
1322         ret = WideCharToMultiByte(CP_ACP, 0, bufferW, retW + 1, buffer, len, NULL, NULL);
1323         if (!ret || ret == len)  /* overflow */
1324         {
1325             ret = len - 2;
1326             buffer[len-2] = 0;
1327             buffer[len-1] = 0;
1328         }
1329         else ret--;
1330     }
1331     else
1332     {
1333         buffer[0] = 0;
1334         buffer[1] = 0;
1335     }
1336
1337     RtlFreeUnicodeString(&sectionW);
1338     RtlFreeUnicodeString(&filenameW);
1339     HeapFree(GetProcessHeap(), 0, bufferW);
1340     return ret;
1341 }
1342
1343 /***********************************************************************
1344  *           GetProfileSectionA   (KERNEL32.@)
1345  */
1346 INT WINAPI GetProfileSectionA( LPCSTR section, LPSTR buffer, DWORD len )
1347 {
1348     return GetPrivateProfileSectionA( section, buffer, len, "win.ini" );
1349 }
1350
1351 /***********************************************************************
1352  *           GetProfileSectionW   (KERNEL32.@)
1353  */
1354 INT WINAPI GetProfileSectionW( LPCWSTR section, LPWSTR buffer, DWORD len )
1355 {
1356     return GetPrivateProfileSectionW( section, buffer, len, wininiW );
1357 }
1358
1359
1360 /***********************************************************************
1361  *           WritePrivateProfileStringW   (KERNEL32.@)
1362  */
1363 BOOL WINAPI WritePrivateProfileStringW( LPCWSTR section, LPCWSTR entry,
1364                                         LPCWSTR string, LPCWSTR filename )
1365 {
1366     BOOL ret = FALSE;
1367
1368     RtlEnterCriticalSection( &PROFILE_CritSect );
1369
1370     if (!section && !entry && !string) /* documented "file flush" case */
1371     {
1372         if (!filename || PROFILE_Open( filename, TRUE ))
1373         {
1374             if (CurProfile) PROFILE_ReleaseFile();  /* always return FALSE in this case */
1375         }
1376     }
1377     else if (PROFILE_Open( filename, TRUE ))
1378     {
1379         if (!section) {
1380             SetLastError(ERROR_FILE_NOT_FOUND);
1381         } else {
1382             ret = PROFILE_SetString( section, entry, string, FALSE);
1383             if (ret) ret = PROFILE_FlushFile();
1384         }
1385     }
1386
1387     RtlLeaveCriticalSection( &PROFILE_CritSect );
1388     return ret;
1389 }
1390
1391 /***********************************************************************
1392  *           WritePrivateProfileStringA   (KERNEL32.@)
1393  */
1394 BOOL WINAPI DECLSPEC_HOTPATCH WritePrivateProfileStringA( LPCSTR section, LPCSTR entry,
1395                                                           LPCSTR string, LPCSTR filename )
1396 {
1397     UNICODE_STRING sectionW, entryW, stringW, filenameW;
1398     BOOL ret;
1399
1400     if (section) RtlCreateUnicodeStringFromAsciiz(&sectionW, section);
1401     else sectionW.Buffer = NULL;
1402     if (entry) RtlCreateUnicodeStringFromAsciiz(&entryW, entry);
1403     else entryW.Buffer = NULL;
1404     if (string) RtlCreateUnicodeStringFromAsciiz(&stringW, string);
1405     else stringW.Buffer = NULL;
1406     if (filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1407     else filenameW.Buffer = NULL;
1408
1409     ret = WritePrivateProfileStringW(sectionW.Buffer, entryW.Buffer,
1410                                      stringW.Buffer, filenameW.Buffer);
1411     RtlFreeUnicodeString(&sectionW);
1412     RtlFreeUnicodeString(&entryW);
1413     RtlFreeUnicodeString(&stringW);
1414     RtlFreeUnicodeString(&filenameW);
1415     return ret;
1416 }
1417
1418 /***********************************************************************
1419  *           WritePrivateProfileSectionW   (KERNEL32.@)
1420  */
1421 BOOL WINAPI WritePrivateProfileSectionW( LPCWSTR section,
1422                                          LPCWSTR string, LPCWSTR filename )
1423 {
1424     BOOL ret = FALSE;
1425     LPWSTR p;
1426
1427     RtlEnterCriticalSection( &PROFILE_CritSect );
1428
1429     if (!section && !string)
1430     {
1431         if (!filename || PROFILE_Open( filename, TRUE ))
1432         {
1433             if (CurProfile) PROFILE_ReleaseFile();  /* always return FALSE in this case */
1434         }
1435     }
1436     else if (PROFILE_Open( filename, TRUE )) {
1437         if (!string) {/* delete the named section*/
1438             ret = PROFILE_SetString(section,NULL,NULL, FALSE);
1439         } else {
1440             PROFILE_DeleteAllKeys(section);
1441             ret = TRUE;
1442             while(*string && ret) {
1443                 LPWSTR buf = HeapAlloc( GetProcessHeap(), 0, (strlenW(string)+1) * sizeof(WCHAR) );
1444                 strcpyW( buf, string );
1445                 if((p = strchrW( buf, '='))) {
1446                     *p='\0';
1447                     ret = PROFILE_SetString( section, buf, p+1, TRUE);
1448                 }
1449                 HeapFree( GetProcessHeap(), 0, buf );
1450                 string += strlenW(string)+1;
1451             }
1452         }
1453         if (ret) ret = PROFILE_FlushFile();
1454     }
1455
1456     RtlLeaveCriticalSection( &PROFILE_CritSect );
1457     return ret;
1458 }
1459
1460 /***********************************************************************
1461  *           WritePrivateProfileSectionA   (KERNEL32.@)
1462  */
1463 BOOL WINAPI WritePrivateProfileSectionA( LPCSTR section,
1464                                          LPCSTR string, LPCSTR filename)
1465
1466 {
1467     UNICODE_STRING sectionW, filenameW;
1468     LPWSTR stringW;
1469     BOOL ret;
1470
1471     if (string)
1472     {
1473         INT lenA, lenW;
1474         LPCSTR p = string;
1475
1476         while(*p) p += strlen(p) + 1;
1477         lenA = p - string + 1;
1478         lenW = MultiByteToWideChar(CP_ACP, 0, string, lenA, NULL, 0);
1479         if ((stringW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR))))
1480             MultiByteToWideChar(CP_ACP, 0, string, lenA, stringW, lenW);
1481     }
1482     else stringW = NULL;
1483     if (section) RtlCreateUnicodeStringFromAsciiz(&sectionW, section);
1484     else sectionW.Buffer = NULL;
1485     if (filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1486     else filenameW.Buffer = NULL;
1487
1488     ret = WritePrivateProfileSectionW(sectionW.Buffer, stringW, filenameW.Buffer);
1489
1490     HeapFree(GetProcessHeap(), 0, stringW);
1491     RtlFreeUnicodeString(&sectionW);
1492     RtlFreeUnicodeString(&filenameW);
1493     return ret;
1494 }
1495
1496 /***********************************************************************
1497  *           WriteProfileSectionA   (KERNEL32.@)
1498  */
1499 BOOL WINAPI WriteProfileSectionA( LPCSTR section, LPCSTR keys_n_values)
1500
1501 {
1502     return WritePrivateProfileSectionA( section, keys_n_values, "win.ini");
1503 }
1504
1505 /***********************************************************************
1506  *           WriteProfileSectionW   (KERNEL32.@)
1507  */
1508 BOOL WINAPI WriteProfileSectionW( LPCWSTR section, LPCWSTR keys_n_values)
1509 {
1510    return WritePrivateProfileSectionW(section, keys_n_values, wininiW);
1511 }
1512
1513
1514 /***********************************************************************
1515  *           GetPrivateProfileSectionNamesW  (KERNEL32.@)
1516  *
1517  * Returns the section names contained in the specified file.
1518  * FIXME: Where do we find this file when the path is relative?
1519  * The section names are returned as a list of strings with an extra
1520  * '\0' to mark the end of the list. Except for that the behavior
1521  * depends on the Windows version.
1522  *
1523  * Win95:
1524  * - if the buffer is 0 or 1 character long then it is as if it was of
1525  *   infinite length.
1526  * - otherwise, if the buffer is too small only the section names that fit
1527  *   are returned.
1528  * - note that this means if the buffer was too small to return even just
1529  *   the first section name then a single '\0' will be returned.
1530  * - the return value is the number of characters written in the buffer,
1531  *   except if the buffer was too small in which case len-2 is returned
1532  *
1533  * Win2000:
1534  * - if the buffer is 0, 1 or 2 characters long then it is filled with
1535  *   '\0' and the return value is 0
1536  * - otherwise if the buffer is too small then the first section name that
1537  *   does not fit is truncated so that the string list can be terminated
1538  *   correctly (double '\0')
1539  * - the return value is the number of characters written in the buffer
1540  *   except for the trailing '\0'. If the buffer is too small, then the
1541  *   return value is len-2
1542  * - Win2000 has a bug that triggers when the section names and the
1543  *   trailing '\0' fit exactly in the buffer. In that case the trailing
1544  *   '\0' is missing.
1545  *
1546  * Wine implements the observed Win2000 behavior (except for the bug).
1547  *
1548  * Note that when the buffer is big enough then the return value may be any
1549  * value between 1 and len-1 (or len in Win95), including len-2.
1550  */
1551 DWORD WINAPI GetPrivateProfileSectionNamesW( LPWSTR buffer, DWORD size,
1552                                              LPCWSTR filename)
1553 {
1554     DWORD ret = 0;
1555
1556     RtlEnterCriticalSection( &PROFILE_CritSect );
1557
1558     if (PROFILE_Open( filename, FALSE ))
1559         ret = PROFILE_GetSectionNames(buffer, size);
1560
1561     RtlLeaveCriticalSection( &PROFILE_CritSect );
1562
1563     return ret;
1564 }
1565
1566
1567 /***********************************************************************
1568  *           GetPrivateProfileSectionNamesA  (KERNEL32.@)
1569  */
1570 DWORD WINAPI GetPrivateProfileSectionNamesA( LPSTR buffer, DWORD size,
1571                                              LPCSTR filename)
1572 {
1573     UNICODE_STRING filenameW;
1574     LPWSTR bufferW;
1575     INT retW, ret = 0;
1576
1577     bufferW = buffer ? HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR)) : NULL;
1578     if (filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1579     else filenameW.Buffer = NULL;
1580
1581     retW = GetPrivateProfileSectionNamesW(bufferW, size, filenameW.Buffer);
1582     if (retW && size)
1583     {
1584         ret = WideCharToMultiByte(CP_ACP, 0, bufferW, retW+1, buffer, size-1, NULL, NULL);
1585         if (!ret)
1586         {
1587             ret = size-2;
1588             buffer[size-1] = 0;
1589         }
1590         else
1591           ret = ret-1;
1592     }
1593     else if(size)
1594         buffer[0] = '\0';
1595
1596     RtlFreeUnicodeString(&filenameW);
1597     HeapFree(GetProcessHeap(), 0, bufferW);
1598     return ret;
1599 }
1600
1601 static int get_hex_byte( const WCHAR *p )
1602 {
1603     int val;
1604
1605     if (*p >= '0' && *p <= '9') val = *p - '0';
1606     else if (*p >= 'A' && *p <= 'Z') val = *p - 'A' + 10;
1607     else if (*p >= 'a' && *p <= 'z') val = *p - 'a' + 10;
1608     else return -1;
1609     val <<= 4;
1610     p++;
1611     if (*p >= '0' && *p <= '9') val += *p - '0';
1612     else if (*p >= 'A' && *p <= 'Z') val += *p - 'A' + 10;
1613     else if (*p >= 'a' && *p <= 'z') val += *p - 'a' + 10;
1614     else return -1;
1615     return val;
1616 }
1617
1618 /***********************************************************************
1619  *           GetPrivateProfileStructW (KERNEL32.@)
1620  *
1621  * Should match Win95's behaviour pretty much
1622  */
1623 BOOL WINAPI GetPrivateProfileStructW (LPCWSTR section, LPCWSTR key,
1624                                       LPVOID buf, UINT len, LPCWSTR filename)
1625 {
1626     BOOL ret = FALSE;
1627     LPBYTE data = buf;
1628     BYTE chksum = 0;
1629     int val;
1630     WCHAR *p, *buffer;
1631
1632     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, (2 * len + 3) * sizeof(WCHAR) ))) return FALSE;
1633
1634     if (GetPrivateProfileStringW( section, key, NULL, buffer, 2 * len + 3, filename ) != 2 * len + 2)
1635         goto done;
1636
1637     for (p = buffer; len; p += 2, len--)
1638     {
1639         if ((val = get_hex_byte( p )) == -1) goto done;
1640         *data++ = val;
1641         chksum += val;
1642     }
1643     /* retrieve stored checksum value */
1644     if ((val = get_hex_byte( p )) == -1) goto done;
1645     ret = ((BYTE)val == chksum);
1646
1647 done:
1648     HeapFree( GetProcessHeap(), 0, buffer );
1649     return ret;
1650 }
1651
1652 /***********************************************************************
1653  *           GetPrivateProfileStructA (KERNEL32.@)
1654  */
1655 BOOL WINAPI GetPrivateProfileStructA (LPCSTR section, LPCSTR key,
1656                                       LPVOID buffer, UINT len, LPCSTR filename)
1657 {
1658     UNICODE_STRING sectionW, keyW, filenameW;
1659     INT ret;
1660
1661     if (section) RtlCreateUnicodeStringFromAsciiz(&sectionW, section);
1662     else sectionW.Buffer = NULL;
1663     if (key) RtlCreateUnicodeStringFromAsciiz(&keyW, key);
1664     else keyW.Buffer = NULL;
1665     if (filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1666     else filenameW.Buffer = NULL;
1667
1668     ret = GetPrivateProfileStructW(sectionW.Buffer, keyW.Buffer, buffer, len,
1669                                    filenameW.Buffer);
1670     /* Do not translate binary data. */
1671
1672     RtlFreeUnicodeString(&sectionW);
1673     RtlFreeUnicodeString(&keyW);
1674     RtlFreeUnicodeString(&filenameW);
1675     return ret;
1676 }
1677
1678
1679
1680 /***********************************************************************
1681  *           WritePrivateProfileStructW (KERNEL32.@)
1682  */
1683 BOOL WINAPI WritePrivateProfileStructW (LPCWSTR section, LPCWSTR key,
1684                                         LPVOID buf, UINT bufsize, LPCWSTR filename)
1685 {
1686     BOOL ret = FALSE;
1687     LPBYTE binbuf;
1688     LPWSTR outstring, p;
1689     DWORD sum = 0;
1690
1691     if (!section && !key && !buf)  /* flush the cache */
1692         return WritePrivateProfileStringW( NULL, NULL, NULL, filename );
1693
1694     /* allocate string buffer for hex chars + checksum hex char + '\0' */
1695     outstring = HeapAlloc( GetProcessHeap(), 0, (bufsize*2 + 2 + 1) * sizeof(WCHAR) );
1696     p = outstring;
1697     for (binbuf = (LPBYTE)buf; binbuf < (LPBYTE)buf+bufsize; binbuf++) {
1698       *p++ = hex[*binbuf >> 4];
1699       *p++ = hex[*binbuf & 0xf];
1700       sum += *binbuf;
1701     }
1702     /* checksum is sum & 0xff */
1703     *p++ = hex[(sum & 0xf0) >> 4];
1704     *p++ = hex[sum & 0xf];
1705     *p++ = '\0';
1706
1707     ret = WritePrivateProfileStringW( section, key, outstring, filename );
1708     HeapFree( GetProcessHeap(), 0, outstring );
1709     return ret;
1710 }
1711
1712 /***********************************************************************
1713  *           WritePrivateProfileStructA (KERNEL32.@)
1714  */
1715 BOOL WINAPI WritePrivateProfileStructA (LPCSTR section, LPCSTR key,
1716                                         LPVOID buf, UINT bufsize, LPCSTR filename)
1717 {
1718     UNICODE_STRING sectionW, keyW, filenameW;
1719     INT ret;
1720
1721     if (section) RtlCreateUnicodeStringFromAsciiz(&sectionW, section);
1722     else sectionW.Buffer = NULL;
1723     if (key) RtlCreateUnicodeStringFromAsciiz(&keyW, key);
1724     else keyW.Buffer = NULL;
1725     if (filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1726     else filenameW.Buffer = NULL;
1727
1728     /* Do not translate binary data. */
1729     ret = WritePrivateProfileStructW(sectionW.Buffer, keyW.Buffer, buf, bufsize,
1730                                      filenameW.Buffer);
1731
1732     RtlFreeUnicodeString(&sectionW);
1733     RtlFreeUnicodeString(&keyW);
1734     RtlFreeUnicodeString(&filenameW);
1735     return ret;
1736 }
1737
1738
1739 /***********************************************************************
1740  *           OpenProfileUserMapping   (KERNEL32.@)
1741  */
1742 BOOL WINAPI OpenProfileUserMapping(void) {
1743     FIXME("(), stub!\n");
1744     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1745     return FALSE;
1746 }
1747
1748 /***********************************************************************
1749  *           CloseProfileUserMapping   (KERNEL32.@)
1750  */
1751 BOOL WINAPI CloseProfileUserMapping(void) {
1752     FIXME("(), stub!\n");
1753     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1754     return FALSE;
1755 }