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