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 1 if a character white space else 0 */
271 static inline int PROFILE_isspaceW(WCHAR c)
272 {
273 /* ^Z (DOS EOF) is a space too (found on CD-ROMs) */
274 return isspaceW(c) || c == 0x1a;
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 line = 0, 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 next_line = memchrW(szLineStart, '\n', szEnd - szLineStart);
406 if (!next_line) next_line = memchrW(szLineStart, '\r', szEnd - szLineStart);
407 if (!next_line) next_line = szEnd;
408 else next_line++;
409 szLineEnd = next_line;
410
411 line++;
412
413 /* get rid of white space */
414 while (szLineStart < szLineEnd && PROFILE_isspaceW(*szLineStart)) szLineStart++;
415 while ((szLineEnd > szLineStart) && PROFILE_isspaceW(szLineEnd[-1])) szLineEnd--;
416
417 if (szLineStart >= szLineEnd) continue;
418
419 if (*szLineStart == '[') /* section start */
420 {
421 const WCHAR * szSectionEnd;
422 if (!(szSectionEnd = memrchrW( szLineStart, ']', szLineEnd - szLineStart )))
423 {
424 WARN("Invalid section header at line %d: %s\n",
425 line, debugstr_wn(szLineStart, (int)(szLineEnd - szLineStart)) );
426 }
427 else
428 {
429 szLineStart++;
430 len = (int)(szSectionEnd - szLineStart);
431 /* no need to allocate +1 for NULL terminating character as
432 * already included in structure */
433 if (!(section = HeapAlloc( GetProcessHeap(), 0, sizeof(*section) + len * sizeof(WCHAR) )))
434 break;
435 memcpy(section->name, szLineStart, len * sizeof(WCHAR));
436 section->name[len] = '\0';
437 section->key = NULL;
438 section->next = NULL;
439 *next_section = section;
440 next_section = §ion->next;
441 next_key = §ion->key;
442 prev_key = NULL;
443
444 TRACE("New section: %s\n", debugstr_w(section->name));
445
446 continue;
447 }
448 }
449
450 /* get rid of white space after the name and before the start
451 * of the value */
452 len = szLineEnd - szLineStart;
453 if ((szValueStart = memchrW( szLineStart, '=', szLineEnd - szLineStart )) != NULL)
454 {
455 const WCHAR *szNameEnd = szValueStart;
456 while ((szNameEnd > szLineStart) && PROFILE_isspaceW(szNameEnd[-1])) szNameEnd--;
457 len = szNameEnd - szLineStart;
458 szValueStart++;
459 while (szValueStart < szLineEnd && PROFILE_isspaceW(*szValueStart)) szValueStart++;
460 }
461
462 if (len || !prev_key || *prev_key->name)
463 {
464 /* no need to allocate +1 for NULL terminating character as
465 * already included in structure */
466 if (!(key = HeapAlloc( GetProcessHeap(), 0, sizeof(*key) + len * sizeof(WCHAR) ))) break;
467 memcpy(key->name, szLineStart, len * sizeof(WCHAR));
468 key->name[len] = '\0';
469 if (szValueStart)
470 {
471 len = (int)(szLineEnd - szValueStart);
472 key->value = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) );
473 memcpy(key->value, szValueStart, len * sizeof(WCHAR));
474 key->value[len] = '\0';
475 }
476 else key->value = NULL;
477
478 key->next = NULL;
479 *next_key = key;
480 next_key = &key->next;
481 prev_key = key;
482
483 TRACE("New key: name=%s, value=%s\n",
484 debugstr_w(key->name), key->value ? debugstr_w(key->value) : "(none)");
485 }
486 }
487 if (szFile != pBuffer)
488 HeapFree(GetProcessHeap(), 0, szFile);
489 HeapFree(GetProcessHeap(), 0, buffer_base);
490 return first_section;
491 }
492
493
494 /***********************************************************************
495 * PROFILE_DeleteSection
496 *
497 * Delete a section from a profile tree.
498 */
499 static BOOL PROFILE_DeleteSection( PROFILESECTION **section, LPCWSTR name )
500 {
501 while (*section)
502 {
503 if ((*section)->name[0] && !strcmpiW( (*section)->name, name ))
504 {
505 PROFILESECTION *to_del = *section;
506 *section = to_del->next;
507 to_del->next = NULL;
508 PROFILE_Free( to_del );
509 return TRUE;
510 }
511 section = &(*section)->next;
512 }
513 return FALSE;
514 }
515
516
517 /***********************************************************************
518 * PROFILE_DeleteKey
519 *
520 * Delete a key from a profile tree.
521 */
522 static BOOL PROFILE_DeleteKey( PROFILESECTION **section,
523 LPCWSTR section_name, LPCWSTR key_name )
524 {
525 while (*section)
526 {
527 if ((*section)->name[0] && !strcmpiW( (*section)->name, section_name ))
528 {
529 PROFILEKEY **key = &(*section)->key;
530 while (*key)
531 {
532 if (!strcmpiW( (*key)->name, key_name ))
533 {
534 PROFILEKEY *to_del = *key;
535 *key = to_del->next;
536 HeapFree( GetProcessHeap(), 0, to_del->value);
537 HeapFree( GetProcessHeap(), 0, to_del );
538 return TRUE;
539 }
540 key = &(*key)->next;
541 }
542 }
543 section = &(*section)->next;
544 }
545 return FALSE;
546 }
547
548
549 /***********************************************************************
550 * PROFILE_DeleteAllKeys
551 *
552 * Delete all keys from a profile tree.
553 */
554 static void PROFILE_DeleteAllKeys( LPCWSTR section_name)
555 {
556 PROFILESECTION **section= &CurProfile->section;
557 while (*section)
558 {
559 if ((*section)->name[0] && !strcmpiW( (*section)->name, section_name ))
560 {
561 PROFILEKEY **key = &(*section)->key;
562 while (*key)
563 {
564 PROFILEKEY *to_del = *key;
565 *key = to_del->next;
566 HeapFree( GetProcessHeap(), 0, to_del->value);
567 HeapFree( GetProcessHeap(), 0, to_del );
568 CurProfile->changed =TRUE;
569 }
570 }
571 section = &(*section)->next;
572 }
573 }
574
575
576 /***********************************************************************
577 * PROFILE_Find
578 *
579 * Find a key in a profile tree, optionally creating it.
580 */
581 static PROFILEKEY *PROFILE_Find( PROFILESECTION **section, LPCWSTR section_name,
582 LPCWSTR key_name, BOOL create, BOOL create_always )
583 {
584 LPCWSTR p;
585 int seclen, keylen;
586
587 while (PROFILE_isspaceW(*section_name)) section_name++;
588 if (*section_name)
589 p = section_name + strlenW(section_name) - 1;
590 else
591 p = section_name;
592
593 while ((p > section_name) && PROFILE_isspaceW(*p)) p--;
594 seclen = p - section_name + 1;
595
596 while (PROFILE_isspaceW(*key_name)) key_name++;
597 if (*key_name)
598 p = key_name + strlenW(key_name) - 1;
599 else
600 p = key_name;
601
602 while ((p > key_name) && PROFILE_isspaceW(*p)) p--;
603 keylen = p - key_name + 1;
604
605 while (*section)
606 {
607 if ( ((*section)->name[0])
608 && (!(strncmpiW( (*section)->name, section_name, seclen )))
609 && (((*section)->name)[seclen] == '\0') )
610 {
611 PROFILEKEY **key = &(*section)->key;
612
613 while (*key)
614 {
615 /* If create_always is FALSE then we check if the keyname
616 * already exists. Otherwise we add it regardless of its
617 * existence, to allow keys to be added more than once in
618 * some cases.
619 */
620 if(!create_always)
621 {
622 if ( (!(strncmpiW( (*key)->name, key_name, keylen )))
623 && (((*key)->name)[keylen] == '\0') )
624 return *key;
625 }
626 key = &(*key)->next;
627 }
628 if (!create) return NULL;
629 if (!(*key = HeapAlloc( GetProcessHeap(), 0, sizeof(PROFILEKEY) + strlenW(key_name) * sizeof(WCHAR) )))
630 return NULL;
631 strcpyW( (*key)->name, key_name );
632 (*key)->value = NULL;
633 (*key)->next = NULL;
634 return *key;
635 }
636 section = &(*section)->next;
637 }
638 if (!create) return NULL;
639 *section = HeapAlloc( GetProcessHeap(), 0, sizeof(PROFILESECTION) + strlenW(section_name) * sizeof(WCHAR) );
640 if(*section == NULL) return NULL;
641 strcpyW( (*section)->name, section_name );
642 (*section)->next = NULL;
643 if (!((*section)->key = HeapAlloc( GetProcessHeap(), 0,
644 sizeof(PROFILEKEY) + strlenW(key_name) * sizeof(WCHAR) )))
645 {
646 HeapFree(GetProcessHeap(), 0, *section);
647 return NULL;
648 }
649 strcpyW( (*section)->key->name, key_name );
650 (*section)->key->value = NULL;
651 (*section)->key->next = NULL;
652 return (*section)->key;
653 }
654
655
656 /***********************************************************************
657 * PROFILE_FlushFile
658 *
659 * Flush the current profile to disk if changed.
660 */
661 static BOOL PROFILE_FlushFile(void)
662 {
663 HANDLE hFile = NULL;
664 FILETIME LastWriteTime;
665
666 if(!CurProfile)
667 {
668 WARN("No current profile!\n");
669 return FALSE;
670 }
671
672 if (!CurProfile->changed) return TRUE;
673
674 hFile = CreateFileW(CurProfile->filename, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
675 NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
676
677 if (hFile == INVALID_HANDLE_VALUE)
678 {
679 WARN("could not save profile file %s (error was %d)\n", debugstr_w(CurProfile->filename), GetLastError());
680 return FALSE;
681 }
682
683 TRACE("Saving %s\n", debugstr_w(CurProfile->filename));
684 PROFILE_Save( hFile, CurProfile->section, CurProfile->encoding );
685 if(GetFileTime(hFile, NULL, NULL, &LastWriteTime))
686 CurProfile->LastWriteTime=LastWriteTime;
687 CloseHandle( hFile );
688 CurProfile->changed = FALSE;
689 return TRUE;
690 }
691
692
693 /***********************************************************************
694 * PROFILE_ReleaseFile
695 *
696 * Flush the current profile to disk and remove it from the cache.
697 */
698 static void PROFILE_ReleaseFile(void)
699 {
700 PROFILE_FlushFile();
701 PROFILE_Free( CurProfile->section );
702 HeapFree( GetProcessHeap(), 0, CurProfile->filename );
703 CurProfile->changed = FALSE;
704 CurProfile->section = NULL;
705 CurProfile->filename = NULL;
706 CurProfile->encoding = ENCODING_ANSI;
707 ZeroMemory(&CurProfile->LastWriteTime, sizeof(CurProfile->LastWriteTime));
708 }
709
710 /***********************************************************************
711 *
712 * Compares a file time with the current time. If the file time is
713 * at least 2.1 seconds in the past, return true.
714 *
715 * Intended as cache safety measure: The time resolution on FAT is
716 * two seconds, so files that are not at least two seconds old might
717 * keep their time even on modification, so don't cache them.
718 */
719 static BOOL is_not_current(FILETIME * ft)
720 {
721 FILETIME Now;
722 LONGLONG ftll, nowll;
723 GetSystemTimeAsFileTime(&Now);
724 ftll = ((LONGLONG)ft->dwHighDateTime << 32) + ft->dwLowDateTime;
725 nowll = ((LONGLONG)Now.dwHighDateTime << 32) + Now.dwLowDateTime;
726 TRACE("%08x;%08x\n",(unsigned)ftll+21000000,(unsigned)nowll);
727 return ftll + 21000000 < nowll;
728 }
729
730 /***********************************************************************
731 * PROFILE_Open
732 *
733 * Open a profile file, checking the cached file first.
734 */
735 static BOOL PROFILE_Open( LPCWSTR filename, BOOL write_access )
736 {
737 WCHAR windirW[MAX_PATH];
738 WCHAR buffer[MAX_PATH];
739 HANDLE hFile = INVALID_HANDLE_VALUE;
740 FILETIME LastWriteTime;
741 int i,j;
742 PROFILE *tempProfile;
743
744 ZeroMemory(&LastWriteTime, sizeof(LastWriteTime));
745
746 /* First time around */
747
748 if(!CurProfile)
749 for(i=0;i<N_CACHED_PROFILES;i++)
750 {
751 MRUProfile[i]=HeapAlloc( GetProcessHeap(), 0, sizeof(PROFILE) );
752 if(MRUProfile[i] == NULL) break;
753 MRUProfile[i]->changed=FALSE;
754 MRUProfile[i]->section=NULL;
755 MRUProfile[i]->filename=NULL;
756 MRUProfile[i]->encoding=ENCODING_ANSI;
757 ZeroMemory(&MRUProfile[i]->LastWriteTime, sizeof(FILETIME));
758 }
759
760 GetWindowsDirectoryW( windirW, MAX_PATH );
761
762 if (!filename)
763 filename = wininiW;
764
765 if ((RtlDetermineDosPathNameType_U(filename) == RELATIVE_PATH) &&
766 !strchrW(filename, '\\') && !strchrW(filename, '/'))
767 {
768 static const WCHAR wszSeparator[] = {'\\', 0};
769 strcpyW(buffer, windirW);
770 strcatW(buffer, wszSeparator);
771 strcatW(buffer, filename);
772 }
773 else
774 {
775 LPWSTR dummy;
776 GetFullPathNameW(filename, sizeof(buffer)/sizeof(buffer[0]), buffer, &dummy);
777 }
778
779 TRACE("path: %s\n", debugstr_w(buffer));
780
781 hFile = CreateFileW(buffer, GENERIC_READ | (write_access ? GENERIC_WRITE : 0),
782 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
783 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
784
785 if ((hFile == INVALID_HANDLE_VALUE) && (GetLastError() != ERROR_FILE_NOT_FOUND))
786 {
787 WARN("Error %d opening file %s\n", GetLastError(), debugstr_w(buffer));
788 return FALSE;
789 }
790
791 for(i=0;i<N_CACHED_PROFILES;i++)
792 {
793 if ((MRUProfile[i]->filename && !strcmpiW( buffer, MRUProfile[i]->filename )))
794 {
795 TRACE("MRU Filename: %s, new filename: %s\n", debugstr_w(MRUProfile[i]->filename), debugstr_w(buffer));
796 if(i)
797 {
798 PROFILE_FlushFile();
799 tempProfile=MRUProfile[i];
800 for(j=i;j>0;j--)
801 MRUProfile[j]=MRUProfile[j-1];
802 CurProfile=tempProfile;
803 }
804
805 if (hFile != INVALID_HANDLE_VALUE)
806 {
807 GetFileTime(hFile, NULL, NULL, &LastWriteTime);
808 if (!memcmp( &CurProfile->LastWriteTime, &LastWriteTime, sizeof(FILETIME) ) &&
809 is_not_current(&LastWriteTime))
810 TRACE("(%s): already opened (mru=%d)\n",
811 debugstr_w(buffer), i);
812 else
813 {
814 TRACE("(%s): already opened, needs refreshing (mru=%d)\n",
815 debugstr_w(buffer), i);
816 PROFILE_Free(CurProfile->section);
817 CurProfile->section = PROFILE_Load(hFile, &CurProfile->encoding);
818 CurProfile->LastWriteTime = LastWriteTime;
819 }
820 CloseHandle(hFile);
821 }
822 else TRACE("(%s): already opened, not yet created (mru=%d)\n",
823 debugstr_w(buffer), i);
824 return TRUE;
825 }
826 }
827
828 /* Flush the old current profile */
829 PROFILE_FlushFile();
830
831 /* Make the oldest profile the current one only in order to get rid of it */
832 if(i==N_CACHED_PROFILES)
833 {
834 tempProfile=MRUProfile[N_CACHED_PROFILES-1];
835 for(i=N_CACHED_PROFILES-1;i>0;i--)
836 MRUProfile[i]=MRUProfile[i-1];
837 CurProfile=tempProfile;
838 }
839 if(CurProfile->filename) PROFILE_ReleaseFile();
840
841 /* OK, now that CurProfile is definitely free we assign it our new file */
842 CurProfile->filename = HeapAlloc( GetProcessHeap(), 0, (strlenW(buffer)+1) * sizeof(WCHAR) );
843 strcpyW( CurProfile->filename, buffer );
844
845 if (hFile != INVALID_HANDLE_VALUE)
846 {
847 CurProfile->section = PROFILE_Load(hFile, &CurProfile->encoding);
848 GetFileTime(hFile, NULL, NULL, &CurProfile->LastWriteTime);
849 CloseHandle(hFile);
850 }
851 else
852 {
853 /* Does not exist yet, we will create it in PROFILE_FlushFile */
854 WARN("profile file %s not found\n", debugstr_w(buffer) );
855 }
856 return TRUE;
857 }
858
859
860 /***********************************************************************
861 * PROFILE_GetSection
862 *
863 * Returns all keys of a section.
864 * If return_values is TRUE, also include the corresponding values.
865 */
866 static INT PROFILE_GetSection( PROFILESECTION *section, LPCWSTR section_name,
867 LPWSTR buffer, UINT len, BOOL return_values )
868 {
869 PROFILEKEY *key;
870
871 if(!buffer) return 0;
872
873 TRACE("%s,%p,%u\n", debugstr_w(section_name), buffer, len);
874
875 while (section)
876 {
877 if (section->name[0] && !strcmpiW( section->name, section_name ))
878 {
879 UINT oldlen = len;
880 for (key = section->key; key; key = key->next)
881 {
882 if (len <= 2) break;
883 if (!*key->name) continue; /* Skip empty lines */
884 if (IS_ENTRY_COMMENT(key->name)) continue; /* Skip comments */
885 if (!return_values && !key->value) continue; /* Skip lines w.o. '=' */
886 PROFILE_CopyEntry( buffer, key->name, len - 1, 0 );
887 len -= strlenW(buffer) + 1;
888 buffer += strlenW(buffer) + 1;
889 if (len < 2)
890 break;
891 if (return_values && key->value) {
892 buffer[-1] = '=';
893 PROFILE_CopyEntry ( buffer, key->value, len - 1, 0 );
894 len -= strlenW(buffer) + 1;
895 buffer += strlenW(buffer) + 1;
896 }
897 }
898 *buffer = '\0';
899 if (len <= 1)
900 /*If either lpszSection or lpszKey is NULL and the supplied
901 destination buffer is too small to hold all the strings,
902 the last string is truncated and followed by two null characters.
903 In this case, the return value is equal to cchReturnBuffer
904 minus two. */
905 {
906 buffer[-1] = '\0';
907 return oldlen - 2;
908 }
909 return oldlen - len;
910 }
911 section = section->next;
912 }
913 buffer[0] = buffer[1] = '\0';
914 return 0;
915 }
916
917 /* See GetPrivateProfileSectionNamesA for documentation */
918 static INT PROFILE_GetSectionNames( LPWSTR buffer, UINT len )
919 {
920 LPWSTR buf;
921 UINT buflen,tmplen;
922 PROFILESECTION *section;
923
924 TRACE("(%p, %d)\n", buffer, len);
925
926 if (!buffer || !len)
927 return 0;
928 if (len==1) {
929 *buffer='\0';
930 return 0;
931 }
932
933 buflen=len-1;
934 buf=buffer;
935 section = CurProfile->section;
936 while ((section!=NULL)) {
937 if (section->name[0]) {
938 tmplen = strlenW(section->name)+1;
939 if (tmplen >= buflen) {
940 if (buflen > 0) {
941 memcpy(buf, section->name, (buflen-1) * sizeof(WCHAR));
942 buf += buflen-1;
943 *buf++='\0';
944 }
945 *buf='\0';
946 return len-2;
947 }
948 memcpy(buf, section->name, tmplen * sizeof(WCHAR));
949 buf += tmplen;
950 buflen -= tmplen;
951 }
952 section = section->next;
953 }
954 *buf='\0';
955 return buf-buffer;
956 }
957
958
959 /***********************************************************************
960 * PROFILE_GetString
961 *
962 * Get a profile string.
963 *
964 * Tests with GetPrivateProfileString16, W95a,
965 * with filled buffer ("****...") and section "set1" and key_name "1" valid:
966 * section key_name def_val res buffer
967 * "set1" "1" "x" 43 [data]
968 * "set1" "1 " "x" 43 [data] (!)
969 * "set1" " 1 "' "x" 43 [data] (!)
970 * "set1" "" "x" 1 "x"
971 * "set1" "" "x " 1 "x" (!)
972 * "set1" "" " x " 3 " x" (!)
973 * "set1" NULL "x" 6 "1\02\03\0\0"
974 * "set1" "" "x" 1 "x"
975 * NULL "1" "x" 0 "" (!)
976 * "" "1" "x" 1 "x"
977 * NULL NULL "" 0 ""
978 *
979 *
980 */
981 static INT PROFILE_GetString( LPCWSTR section, LPCWSTR key_name,
982 LPCWSTR def_val, LPWSTR buffer, UINT len )
983 {
984 PROFILEKEY *key = NULL;
985 static const WCHAR empty_strW[] = { 0 };
986
987 if(!buffer || !len) return 0;
988
989 if (!def_val) def_val = empty_strW;
990 if (key_name)
991 {
992 if (!key_name[0])
993 {
994 PROFILE_CopyEntry(buffer, def_val, len, TRUE);
995 return strlenW(buffer);
996 }
997 key = PROFILE_Find( &CurProfile->section, section, key_name, FALSE, FALSE);
998 PROFILE_CopyEntry( buffer, (key && key->value) ? key->value : def_val,
999 len, TRUE );
1000 TRACE("(%s,%s,%s): returning %s\n",
1001 debugstr_w(section), debugstr_w(key_name),
1002 debugstr_w(def_val), debugstr_w(buffer) );
1003 return strlenW( buffer );
1004 }
1005 /* no "else" here ! */
1006 if (section && section[0])
1007 {
1008 INT ret = PROFILE_GetSection(CurProfile->section, section, buffer, len, FALSE);
1009 if (!buffer[0]) /* no luck -> def_val */
1010 {
1011 PROFILE_CopyEntry(buffer, def_val, len, TRUE);
1012 ret = strlenW(buffer);
1013 }
1014 return ret;
1015 }
1016 buffer[0] = '\0';
1017 return 0;
1018 }
1019
1020
1021 /***********************************************************************
1022 * PROFILE_SetString
1023 *
1024 * Set a profile string.
1025 */
1026 static BOOL PROFILE_SetString( LPCWSTR section_name, LPCWSTR key_name,
1027 LPCWSTR value, BOOL create_always )
1028 {
1029 if (!key_name) /* Delete a whole section */
1030 {
1031 TRACE("(%s)\n", debugstr_w(section_name));
1032 CurProfile->changed |= PROFILE_DeleteSection( &CurProfile->section,
1033 section_name );
1034 return TRUE; /* Even if PROFILE_DeleteSection() has failed,
1035 this is not an error on application's level.*/
1036 }
1037 else if (!value) /* Delete a key */
1038 {
1039 TRACE("(%s,%s)\n", debugstr_w(section_name), debugstr_w(key_name) );
1040 CurProfile->changed |= PROFILE_DeleteKey( &CurProfile->section,
1041 section_name, key_name );
1042 return TRUE; /* same error handling as above */
1043 }
1044 else /* Set the key value */
1045 {
1046 PROFILEKEY *key = PROFILE_Find(&CurProfile->section, section_name,
1047 key_name, TRUE, create_always );
1048 TRACE("(%s,%s,%s):\n",
1049 debugstr_w(section_name), debugstr_w(key_name), debugstr_w(value) );
1050 if (!key) return FALSE;
1051
1052 /* strip the leading spaces. We can safely strip \n\r and
1053 * friends too, they should not happen here anyway. */
1054 while (PROFILE_isspaceW(*value)) value++;
1055
1056 if (key->value)
1057 {
1058 if (!strcmpW( key->value, value ))
1059 {
1060 TRACE(" no change needed\n" );
1061 return TRUE; /* No change needed */
1062 }
1063 TRACE(" replacing %s\n", debugstr_w(key->value) );
1064 HeapFree( GetProcessHeap(), 0, key->value );
1065 }
1066 else TRACE(" creating key\n" );
1067 key->value = HeapAlloc( GetProcessHeap(), 0, (strlenW(value)+1) * sizeof(WCHAR) );
1068 strcpyW( key->value, value );
1069 CurProfile->changed = TRUE;
1070 }
1071 return TRUE;
1072 }
1073
1074
1075 /********************* API functions **********************************/
1076
1077
1078 /***********************************************************************
1079 * GetProfileIntA (KERNEL32.@)
1080 */
1081 UINT WINAPI GetProfileIntA( LPCSTR section, LPCSTR entry, INT def_val )
1082 {
1083 return GetPrivateProfileIntA( section, entry, def_val, "win.ini" );
1084 }
1085
1086 /***********************************************************************
1087 * GetProfileIntW (KERNEL32.@)
1088 */
1089 UINT WINAPI GetProfileIntW( LPCWSTR section, LPCWSTR entry, INT def_val )
1090 {
1091 return GetPrivateProfileIntW( section, entry, def_val, wininiW );
1092 }
1093
1094 /***********************************************************************
1095 * GetPrivateProfileStringW (KERNEL32.@)
1096 */
1097 INT WINAPI GetPrivateProfileStringW( LPCWSTR section, LPCWSTR entry,
1098 LPCWSTR def_val, LPWSTR buffer,
1099 UINT len, LPCWSTR filename )
1100 {
1101 int ret;
1102 LPWSTR defval_tmp = NULL;
1103
1104 TRACE("%s,%s,%s,%p,%u,%s\n", debugstr_w(section), debugstr_w(entry),
1105 debugstr_w(def_val), buffer, len, debugstr_w(filename));
1106
1107 /* strip any trailing ' ' of def_val. */
1108 if (def_val)
1109 {
1110 LPCWSTR p = def_val + strlenW(def_val) - 1;
1111
1112 while (p > def_val && *p == ' ')
1113 p--;
1114
1115 if (p >= def_val)
1116 {
1117 int len = (int)(p - def_val) + 1;
1118
1119 defval_tmp = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
1120 memcpy(defval_tmp, def_val, len * sizeof(WCHAR));
1121 defval_tmp[len] = '\0';
1122 def_val = defval_tmp;
1123 }
1124 }
1125
1126 RtlEnterCriticalSection( &PROFILE_CritSect );
1127
1128 if (PROFILE_Open( filename, FALSE )) {
1129 if (section == NULL)
1130 ret = PROFILE_GetSectionNames(buffer, len);
1131 else
1132 /* PROFILE_GetString can handle the 'entry == NULL' case */
1133 ret = PROFILE_GetString( section, entry, def_val, buffer, len );
1134 } else if (buffer && def_val) {
1135 lstrcpynW( buffer, def_val, len );
1136 ret = strlenW( buffer );
1137 }
1138 else
1139 ret = 0;
1140
1141 RtlLeaveCriticalSection( &PROFILE_CritSect );
1142
1143 HeapFree(GetProcessHeap(), 0, defval_tmp);
1144
1145 TRACE("returning %s, %d\n", debugstr_w(buffer), ret);
1146
1147 return ret;
1148 }
1149
1150 /***********************************************************************
1151 * GetPrivateProfileStringA (KERNEL32.@)
1152 */
1153 INT WINAPI GetPrivateProfileStringA( LPCSTR section, LPCSTR entry,
1154 LPCSTR def_val, LPSTR buffer,
1155 UINT len, LPCSTR filename )
1156 {
1157 UNICODE_STRING sectionW, entryW, def_valW, filenameW;
1158 LPWSTR bufferW;
1159 INT retW, ret = 0;
1160
1161 bufferW = buffer ? HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)) : NULL;
1162 if (section) RtlCreateUnicodeStringFromAsciiz(§ionW, section);
1163 else sectionW.Buffer = NULL;
1164 if (entry) RtlCreateUnicodeStringFromAsciiz(&entryW, entry);
1165 else entryW.Buffer = NULL;
1166 if (def_val) RtlCreateUnicodeStringFromAsciiz(&def_valW, def_val);
1167 else def_valW.Buffer = NULL;
1168 if (filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1169 else filenameW.Buffer = NULL;
1170
1171 retW = GetPrivateProfileStringW( sectionW.Buffer, entryW.Buffer,
1172 def_valW.Buffer, bufferW, len,
1173 filenameW.Buffer);
1174 if (len)
1175 {
1176 ret = WideCharToMultiByte(CP_ACP, 0, bufferW, retW + 1, buffer, len, NULL, NULL);
1177 if (!ret)
1178 {
1179 ret = len - 1;
1180 buffer[ret] = 0;
1181 }
1182 else
1183 ret--; /* strip terminating 0 */
1184 }
1185
1186 RtlFreeUnicodeString(§ionW);
1187 RtlFreeUnicodeString(&entryW);
1188 RtlFreeUnicodeString(&def_valW);
1189 RtlFreeUnicodeString(&filenameW);
1190 HeapFree(GetProcessHeap(), 0, bufferW);
1191 return ret;
1192 }
1193
1194 /***********************************************************************
1195 * GetProfileStringA (KERNEL32.@)
1196 */
1197 INT WINAPI GetProfileStringA( LPCSTR section, LPCSTR entry, LPCSTR def_val,
1198 LPSTR buffer, UINT len )
1199 {
1200 return GetPrivateProfileStringA( section, entry, def_val,
1201 buffer, len, "win.ini" );
1202 }
1203
1204 /***********************************************************************
1205 * GetProfileStringW (KERNEL32.@)
1206 */
1207 INT WINAPI GetProfileStringW( LPCWSTR section, LPCWSTR entry,
1208 LPCWSTR def_val, LPWSTR buffer, UINT len )
1209 {
1210 return GetPrivateProfileStringW( section, entry, def_val,
1211 buffer, len, wininiW );
1212 }
1213
1214 /***********************************************************************
1215 * WriteProfileStringA (KERNEL32.@)
1216 */
1217 BOOL WINAPI WriteProfileStringA( LPCSTR section, LPCSTR entry,
1218 LPCSTR string )
1219 {
1220 return WritePrivateProfileStringA( section, entry, string, "win.ini" );
1221 }
1222
1223 /***********************************************************************
1224 * WriteProfileStringW (KERNEL32.@)
1225 */
1226 BOOL WINAPI WriteProfileStringW( LPCWSTR section, LPCWSTR entry,
1227 LPCWSTR string )
1228 {
1229 return WritePrivateProfileStringW( section, entry, string, wininiW );
1230 }
1231
1232
1233 /***********************************************************************
1234 * GetPrivateProfileIntW (KERNEL32.@)
1235 */
1236 UINT WINAPI GetPrivateProfileIntW( LPCWSTR section, LPCWSTR entry,
1237 INT def_val, LPCWSTR filename )
1238 {
1239 WCHAR buffer[30];
1240 UNICODE_STRING bufferW;
1241 INT len;
1242 ULONG result;
1243
1244 if (!(len = GetPrivateProfileStringW( section, entry, emptystringW,
1245 buffer, sizeof(buffer)/sizeof(WCHAR),
1246 filename )))
1247 return def_val;
1248
1249 /* FIXME: if entry can be found but it's empty, then Win16 is
1250 * supposed to return 0 instead of def_val ! Difficult/problematic
1251 * to implement (every other failure also returns zero buffer),
1252 * thus wait until testing framework avail for making sure nothing
1253 * else gets broken that way. */
1254 if (!buffer[0]) return (UINT)def_val;
1255
1256 RtlInitUnicodeString( &bufferW, buffer );
1257 RtlUnicodeStringToInteger( &bufferW, 0, &result);
1258 return result;
1259 }
1260
1261 /***********************************************************************
1262 * GetPrivateProfileIntA (KERNEL32.@)
1263 *
1264 * FIXME: rewrite using unicode
1265 */
1266 UINT WINAPI GetPrivateProfileIntA( LPCSTR section, LPCSTR entry,
1267 INT def_val, LPCSTR filename )
1268 {
1269 UNICODE_STRING entryW, filenameW, sectionW;
1270 UINT res;
1271 if(entry) RtlCreateUnicodeStringFromAsciiz(&entryW, entry);
1272 else entryW.Buffer = NULL;
1273 if(filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1274 else filenameW.Buffer = NULL;
1275 if(section) RtlCreateUnicodeStringFromAsciiz(§ionW, section);
1276 else sectionW.Buffer = NULL;
1277 res = GetPrivateProfileIntW(sectionW.Buffer, entryW.Buffer, def_val,
1278 filenameW.Buffer);
1279 RtlFreeUnicodeString(§ionW);
1280 RtlFreeUnicodeString(&filenameW);
1281 RtlFreeUnicodeString(&entryW);
1282 return res;
1283 }
1284
1285 /***********************************************************************
1286 * GetPrivateProfileSectionW (KERNEL32.@)
1287 */
1288 INT WINAPI GetPrivateProfileSectionW( LPCWSTR section, LPWSTR buffer,
1289 DWORD len, LPCWSTR filename )
1290 {
1291 int ret = 0;
1292
1293 if (!section || !buffer)
1294 {
1295 SetLastError(ERROR_INVALID_PARAMETER);
1296 return 0;
1297 }
1298
1299 TRACE("(%s, %p, %d, %s)\n", debugstr_w(section), buffer, len, debugstr_w(filename));
1300
1301 RtlEnterCriticalSection( &PROFILE_CritSect );
1302
1303 if (PROFILE_Open( filename, FALSE ))
1304 ret = PROFILE_GetSection(CurProfile->section, section, buffer, len, TRUE);
1305
1306 RtlLeaveCriticalSection( &PROFILE_CritSect );
1307
1308 return ret;
1309 }
1310
1311 /***********************************************************************
1312 * GetPrivateProfileSectionA (KERNEL32.@)
1313 */
1314 INT WINAPI GetPrivateProfileSectionA( LPCSTR section, LPSTR buffer,
1315 DWORD len, LPCSTR filename )
1316 {
1317 UNICODE_STRING sectionW, filenameW;
1318 LPWSTR bufferW;
1319 INT retW, ret = 0;
1320
1321 if (!section || !buffer)
1322 {
1323 SetLastError(ERROR_INVALID_PARAMETER);
1324 return 0;
1325 }
1326
1327 bufferW = HeapAlloc(GetProcessHeap(), 0, len * 2 * sizeof(WCHAR));
1328 RtlCreateUnicodeStringFromAsciiz(§ionW, section);
1329 if (filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1330 else filenameW.Buffer = NULL;
1331
1332 retW = GetPrivateProfileSectionW(sectionW.Buffer, bufferW, len * 2, filenameW.Buffer);
1333 if (retW)
1334 {
1335 if (retW == len * 2 - 2) retW++; /* overflow */
1336 ret = WideCharToMultiByte(CP_ACP, 0, bufferW, retW + 1, buffer, len, NULL, NULL);
1337 if (!ret || ret == len) /* overflow */
1338 {
1339 ret = len - 2;
1340 buffer[len-2] = 0;
1341 buffer[len-1] = 0;
1342 }
1343 else ret--;
1344 }
1345 else
1346 {
1347 buffer[0] = 0;
1348 buffer[1] = 0;
1349 }
1350
1351 RtlFreeUnicodeString(§ionW);
1352 RtlFreeUnicodeString(&filenameW);
1353 HeapFree(GetProcessHeap(), 0, bufferW);
1354 return ret;
1355 }
1356
1357 /***********************************************************************
1358 * GetProfileSectionA (KERNEL32.@)
1359 */
1360 INT WINAPI GetProfileSectionA( LPCSTR section, LPSTR buffer, DWORD len )
1361 {
1362 return GetPrivateProfileSectionA( section, buffer, len, "win.ini" );
1363 }
1364
1365 /***********************************************************************
1366 * GetProfileSectionW (KERNEL32.@)
1367 */
1368 INT WINAPI GetProfileSectionW( LPCWSTR section, LPWSTR buffer, DWORD len )
1369 {
1370 return GetPrivateProfileSectionW( section, buffer, len, wininiW );
1371 }
1372
1373
1374 /***********************************************************************
1375 * WritePrivateProfileStringW (KERNEL32.@)
1376 */
1377 BOOL WINAPI WritePrivateProfileStringW( LPCWSTR section, LPCWSTR entry,
1378 LPCWSTR string, LPCWSTR filename )
1379 {
1380 BOOL ret = FALSE;
1381
1382 RtlEnterCriticalSection( &PROFILE_CritSect );
1383
1384 if (!section && !entry && !string) /* documented "file flush" case */
1385 {
1386 if (!filename || PROFILE_Open( filename, TRUE ))
1387 {
1388 if (CurProfile) PROFILE_ReleaseFile(); /* always return FALSE in this case */
1389 }
1390 }
1391 else if (PROFILE_Open( filename, TRUE ))
1392 {
1393 if (!section) {
1394 SetLastError(ERROR_FILE_NOT_FOUND);
1395 } else {
1396 ret = PROFILE_SetString( section, entry, string, FALSE);
1397 PROFILE_FlushFile();
1398 }
1399 }
1400
1401 RtlLeaveCriticalSection( &PROFILE_CritSect );
1402 return ret;
1403 }
1404
1405 /***********************************************************************
1406 * WritePrivateProfileStringA (KERNEL32.@)
1407 */
1408 BOOL WINAPI WritePrivateProfileStringA( LPCSTR section, LPCSTR entry,
1409 LPCSTR string, LPCSTR filename )
1410 {
1411 UNICODE_STRING sectionW, entryW, stringW, filenameW;
1412 BOOL ret;
1413
1414 if (section) RtlCreateUnicodeStringFromAsciiz(§ionW, section);
1415 else sectionW.Buffer = NULL;
1416 if (entry) RtlCreateUnicodeStringFromAsciiz(&entryW, entry);
1417 else entryW.Buffer = NULL;
1418 if (string) RtlCreateUnicodeStringFromAsciiz(&stringW, string);
1419 else stringW.Buffer = NULL;
1420 if (filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1421 else filenameW.Buffer = NULL;
1422
1423 ret = WritePrivateProfileStringW(sectionW.Buffer, entryW.Buffer,
1424 stringW.Buffer, filenameW.Buffer);
1425 RtlFreeUnicodeString(§ionW);
1426 RtlFreeUnicodeString(&entryW);
1427 RtlFreeUnicodeString(&stringW);
1428 RtlFreeUnicodeString(&filenameW);
1429 return ret;
1430 }
1431
1432 /***********************************************************************
1433 * WritePrivateProfileSectionW (KERNEL32.@)
1434 */
1435 BOOL WINAPI WritePrivateProfileSectionW( LPCWSTR section,
1436 LPCWSTR string, LPCWSTR filename )
1437 {
1438 BOOL ret = FALSE;
1439 LPWSTR p;
1440
1441 RtlEnterCriticalSection( &PROFILE_CritSect );
1442
1443 if (!section && !string)
1444 {
1445 if (!filename || PROFILE_Open( filename, TRUE ))
1446 {
1447 if (CurProfile) PROFILE_ReleaseFile(); /* always return FALSE in this case */
1448 }
1449 }
1450 else if (PROFILE_Open( filename, TRUE )) {
1451 if (!string) {/* delete the named section*/
1452 ret = PROFILE_SetString(section,NULL,NULL, FALSE);
1453 PROFILE_FlushFile();
1454 } else {
1455 PROFILE_DeleteAllKeys(section);
1456 ret = TRUE;
1457 while(*string) {
1458 LPWSTR buf = HeapAlloc( GetProcessHeap(), 0, (strlenW(string)+1) * sizeof(WCHAR) );
1459 strcpyW( buf, string );
1460 if((p = strchrW( buf, '='))) {
1461 *p='\0';
1462 ret = PROFILE_SetString( section, buf, p+1, TRUE);
1463 }
1464 HeapFree( GetProcessHeap(), 0, buf );
1465 string += strlenW(string)+1;
1466 }
1467 PROFILE_FlushFile();
1468 }
1469 }
1470
1471 RtlLeaveCriticalSection( &PROFILE_CritSect );
1472 return ret;
1473 }
1474
1475 /***********************************************************************
1476 * WritePrivateProfileSectionA (KERNEL32.@)
1477 */
1478 BOOL WINAPI WritePrivateProfileSectionA( LPCSTR section,
1479 LPCSTR string, LPCSTR filename)
1480
1481 {
1482 UNICODE_STRING sectionW, filenameW;
1483 LPWSTR stringW;
1484 BOOL ret;
1485
1486 if (string)
1487 {
1488 INT lenA, lenW;
1489 LPCSTR p = string;
1490
1491 while(*p) p += strlen(p) + 1;
1492 lenA = p - string + 1;
1493 lenW = MultiByteToWideChar(CP_ACP, 0, string, lenA, NULL, 0);
1494 if ((stringW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR))))
1495 MultiByteToWideChar(CP_ACP, 0, string, lenA, stringW, lenW);
1496 }
1497 else stringW = NULL;
1498 if (section) RtlCreateUnicodeStringFromAsciiz(§ionW, section);
1499 else sectionW.Buffer = NULL;
1500 if (filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1501 else filenameW.Buffer = NULL;
1502
1503 ret = WritePrivateProfileSectionW(sectionW.Buffer, stringW, filenameW.Buffer);
1504
1505 HeapFree(GetProcessHeap(), 0, stringW);
1506 RtlFreeUnicodeString(§ionW);
1507 RtlFreeUnicodeString(&filenameW);
1508 return ret;
1509 }
1510
1511 /***********************************************************************
1512 * WriteProfileSectionA (KERNEL32.@)
1513 */
1514 BOOL WINAPI WriteProfileSectionA( LPCSTR section, LPCSTR keys_n_values)
1515
1516 {
1517 return WritePrivateProfileSectionA( section, keys_n_values, "win.ini");
1518 }
1519
1520 /***********************************************************************
1521 * WriteProfileSectionW (KERNEL32.@)
1522 */
1523 BOOL WINAPI WriteProfileSectionW( LPCWSTR section, LPCWSTR keys_n_values)
1524 {
1525 return WritePrivateProfileSectionW(section, keys_n_values, wininiW);
1526 }
1527
1528
1529 /***********************************************************************
1530 * GetPrivateProfileSectionNamesW (KERNEL32.@)
1531 *
1532 * Returns the section names contained in the specified file.
1533 * FIXME: Where do we find this file when the path is relative?
1534 * The section names are returned as a list of strings with an extra
1535 * '\0' to mark the end of the list. Except for that the behavior
1536 * depends on the Windows version.
1537 *
1538 * Win95:
1539 * - if the buffer is 0 or 1 character long then it is as if it was of
1540 * infinite length.
1541 * - otherwise, if the buffer is too small only the section names that fit
1542 * are returned.
1543 * - note that this means if the buffer was too small to return even just
1544 * the first section name then a single '\0' will be returned.
1545 * - the return value is the number of characters written in the buffer,
1546 * except if the buffer was too small in which case len-2 is returned
1547 *
1548 * Win2000:
1549 * - if the buffer is 0, 1 or 2 characters long then it is filled with
1550 * '\0' and the return value is 0
1551 * - otherwise if the buffer is too small then the first section name that
1552 * does not fit is truncated so that the string list can be terminated
1553 * correctly (double '\0')
1554 * - the return value is the number of characters written in the buffer
1555 * except for the trailing '\0'. If the buffer is too small, then the
1556 * return value is len-2
1557 * - Win2000 has a bug that triggers when the section names and the
1558 * trailing '\0' fit exactly in the buffer. In that case the trailing
1559 * '\0' is missing.
1560 *
1561 * Wine implements the observed Win2000 behavior (except for the bug).
1562 *
1563 * Note that when the buffer is big enough then the return value may be any
1564 * value between 1 and len-1 (or len in Win95), including len-2.
1565 */
1566 DWORD WINAPI GetPrivateProfileSectionNamesW( LPWSTR buffer, DWORD size,
1567 LPCWSTR filename)
1568 {
1569 DWORD ret = 0;
1570
1571 RtlEnterCriticalSection( &PROFILE_CritSect );
1572
1573 if (PROFILE_Open( filename, FALSE ))
1574 ret = PROFILE_GetSectionNames(buffer, size);
1575
1576 RtlLeaveCriticalSection( &PROFILE_CritSect );
1577
1578 return ret;
1579 }
1580
1581
1582 /***********************************************************************
1583 * GetPrivateProfileSectionNamesA (KERNEL32.@)
1584 */
1585 DWORD WINAPI GetPrivateProfileSectionNamesA( LPSTR buffer, DWORD size,
1586 LPCSTR filename)
1587 {
1588 UNICODE_STRING filenameW;
1589 LPWSTR bufferW;
1590 INT retW, ret = 0;
1591
1592 bufferW = buffer ? HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR)) : NULL;
1593 if (filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1594 else filenameW.Buffer = NULL;
1595
1596 retW = GetPrivateProfileSectionNamesW(bufferW, size, filenameW.Buffer);
1597 if (retW && size)
1598 {
1599 ret = WideCharToMultiByte(CP_ACP, 0, bufferW, retW+1, buffer, size-1, NULL, NULL);
1600 if (!ret)
1601 {
1602 ret = size-2;
1603 buffer[size-1] = 0;
1604 }
1605 else
1606 ret = ret-1;
1607 }
1608 else if(size)
1609 buffer[0] = '\0';
1610
1611 RtlFreeUnicodeString(&filenameW);
1612 HeapFree(GetProcessHeap(), 0, bufferW);
1613 return ret;
1614 }
1615
1616 /***********************************************************************
1617 * GetPrivateProfileStructW (KERNEL32.@)
1618 *
1619 * Should match Win95's behaviour pretty much
1620 */
1621 BOOL WINAPI GetPrivateProfileStructW (LPCWSTR section, LPCWSTR key,
1622 LPVOID buf, UINT len, LPCWSTR filename)
1623 {
1624 BOOL ret = FALSE;
1625
1626 RtlEnterCriticalSection( &PROFILE_CritSect );
1627
1628 if (PROFILE_Open( filename, FALSE )) {
1629 PROFILEKEY *k = PROFILE_Find ( &CurProfile->section, section, key, FALSE, FALSE);
1630 if (k) {
1631 TRACE("value (at %p): %s\n", k->value, debugstr_w(k->value));
1632 if (((strlenW(k->value) - 2) / 2) == len)
1633 {
1634 LPWSTR end, p;
1635 BOOL valid = TRUE;
1636 WCHAR c;
1637 DWORD chksum = 0;
1638
1639 end = k->value + strlenW(k->value); /* -> '\0' */
1640 /* check for invalid chars in ASCII coded hex string */
1641 for (p=k->value; p < end; p++)
1642 {
1643 if (!isxdigitW(*p))
1644 {
1645 WARN("invalid char '%x' in file %s->[%s]->%s !\n",
1646 *p, debugstr_w(filename), debugstr_w(section), debugstr_w(key));
1647 valid = FALSE;
1648 break;
1649 }
1650 }
1651 if (valid)
1652 {
1653 BOOL highnibble = TRUE;
1654 BYTE b = 0, val;
1655 LPBYTE binbuf = buf;
1656
1657 end -= 2; /* don't include checksum in output data */
1658 /* translate ASCII hex format into binary data */
1659 for (p=k->value; p < end; p++)
1660 {
1661 c = toupperW(*p);
1662 val = (c > '9') ?
1663 (c - 'A' + 10) : (c - '');
1664
1665 if (highnibble)
1666 b = val << 4;
1667 else
1668 {
1669 b += val;
1670 *binbuf++ = b; /* feed binary data into output */
1671 chksum += b; /* calculate checksum */
1672 }
1673 highnibble ^= 1; /* toggle */
1674 }
1675 /* retrieve stored checksum value */
1676 c = toupperW(*p++);
1677 b = ( (c > '9') ? (c - 'A' + 10) : (c - '') ) << 4;
1678 c = toupperW(*p);
1679 b += (c > '9') ? (c - 'A' + 10) : (c - '');
1680 if (b == (chksum & 0xff)) /* checksums match ? */
1681 ret = TRUE;
1682 }
1683 }
1684 }
1685 }
1686 RtlLeaveCriticalSection( &PROFILE_CritSect );
1687
1688 return ret;
1689 }
1690
1691 /***********************************************************************
1692 * GetPrivateProfileStructA (KERNEL32.@)
1693 */
1694 BOOL WINAPI GetPrivateProfileStructA (LPCSTR section, LPCSTR key,
1695 LPVOID buffer, UINT len, LPCSTR filename)
1696 {
1697 UNICODE_STRING sectionW, keyW, filenameW;
1698 INT ret;
1699
1700 if (section) RtlCreateUnicodeStringFromAsciiz(§ionW, section);
1701 else sectionW.Buffer = NULL;
1702 if (key) RtlCreateUnicodeStringFromAsciiz(&keyW, key);
1703 else keyW.Buffer = NULL;
1704 if (filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1705 else filenameW.Buffer = NULL;
1706
1707 ret = GetPrivateProfileStructW(sectionW.Buffer, keyW.Buffer, buffer, len,
1708 filenameW.Buffer);
1709 /* Do not translate binary data. */
1710
1711 RtlFreeUnicodeString(§ionW);
1712 RtlFreeUnicodeString(&keyW);
1713 RtlFreeUnicodeString(&filenameW);
1714 return ret;
1715 }
1716
1717
1718
1719 /***********************************************************************
1720 * WritePrivateProfileStructW (KERNEL32.@)
1721 */
1722 BOOL WINAPI WritePrivateProfileStructW (LPCWSTR section, LPCWSTR key,
1723 LPVOID buf, UINT bufsize, LPCWSTR filename)
1724 {
1725 BOOL ret = FALSE;
1726 LPBYTE binbuf;
1727 LPWSTR outstring, p;
1728 DWORD sum = 0;
1729
1730 if (!section && !key && !buf) /* flush the cache */
1731 return WritePrivateProfileStringW( NULL, NULL, NULL, filename );
1732
1733 /* allocate string buffer for hex chars + checksum hex char + '\0' */
1734 outstring = HeapAlloc( GetProcessHeap(), 0, (bufsize*2 + 2 + 1) * sizeof(WCHAR) );
1735 p = outstring;
1736 for (binbuf = (LPBYTE)buf; binbuf < (LPBYTE)buf+bufsize; binbuf++) {
1737 *p++ = hex[*binbuf >> 4];
1738 *p++ = hex[*binbuf & 0xf];
1739 sum += *binbuf;
1740 }
1741 /* checksum is sum & 0xff */
1742 *p++ = hex[(sum & 0xf0) >> 4];
1743 *p++ = hex[sum & 0xf];
1744 *p++ = '\0';
1745
1746 RtlEnterCriticalSection( &PROFILE_CritSect );
1747
1748 if (PROFILE_Open( filename, TRUE )) {
1749 ret = PROFILE_SetString( section, key, outstring, FALSE);
1750 PROFILE_FlushFile();
1751 }
1752
1753 RtlLeaveCriticalSection( &PROFILE_CritSect );
1754
1755 HeapFree( GetProcessHeap(), 0, outstring );
1756
1757 return ret;
1758 }
1759
1760 /***********************************************************************
1761 * WritePrivateProfileStructA (KERNEL32.@)
1762 */
1763 BOOL WINAPI WritePrivateProfileStructA (LPCSTR section, LPCSTR key,
1764 LPVOID buf, UINT bufsize, LPCSTR filename)
1765 {
1766 UNICODE_STRING sectionW, keyW, filenameW;
1767 INT ret;
1768
1769 if (section) RtlCreateUnicodeStringFromAsciiz(§ionW, section);
1770 else sectionW.Buffer = NULL;
1771 if (key) RtlCreateUnicodeStringFromAsciiz(&keyW, key);
1772 else keyW.Buffer = NULL;
1773 if (filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1774 else filenameW.Buffer = NULL;
1775
1776 /* Do not translate binary data. */
1777 ret = WritePrivateProfileStructW(sectionW.Buffer, keyW.Buffer, buf, bufsize,
1778 filenameW.Buffer);
1779
1780 RtlFreeUnicodeString(§ionW);
1781 RtlFreeUnicodeString(&keyW);
1782 RtlFreeUnicodeString(&filenameW);
1783 return ret;
1784 }
1785
1786
1787 /***********************************************************************
1788 * OpenProfileUserMapping (KERNEL32.@)
1789 */
1790 BOOL WINAPI OpenProfileUserMapping(void) {
1791 FIXME("(), stub!\n");
1792 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1793 return FALSE;
1794 }
1795
1796 /***********************************************************************
1797 * CloseProfileUserMapping (KERNEL32.@)
1798 */
1799 BOOL WINAPI CloseProfileUserMapping(void) {
1800 FIXME("(), stub!\n");
1801 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1802 return FALSE;
1803 }
1804
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.