?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winegcc: Add detection for --param options.
[wine/multimedia.git] / dlls / kernel32 / profile.c
blob26c67369df50d959a7e633ff50ea6c6772452aaf
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 = &section->next;
441 next_key = &section->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(&sectionW, 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 && buffer)
1175 {
1176 if (retW)
1177 {
1178 ret = WideCharToMultiByte(CP_ACP, 0, bufferW, retW, buffer, len - 1, NULL, NULL);
1179 if (!ret)
1180 ret = len - 1;
1181 }
1182 buffer[ret] = 0;
1183 }
1184
1185 RtlFreeUnicodeString(&sectionW);
1186 RtlFreeUnicodeString(&entryW);
1187 RtlFreeUnicodeString(&def_valW);
1188 RtlFreeUnicodeString(&filenameW);
1189 HeapFree(GetProcessHeap(), 0, bufferW);
1190 return ret;
1191 }
1192
1193 /***********************************************************************
1194 * GetProfileStringA (KERNEL32.@)
1195 */
1196 INT WINAPI GetProfileStringA( LPCSTR section, LPCSTR entry, LPCSTR def_val,
1197 LPSTR buffer, UINT len )
1198 {
1199 return GetPrivateProfileStringA( section, entry, def_val,
1200 buffer, len, "win.ini" );
1201 }
1202
1203 /***********************************************************************
1204 * GetProfileStringW (KERNEL32.@)
1205 */
1206 INT WINAPI GetProfileStringW( LPCWSTR section, LPCWSTR entry,
1207 LPCWSTR def_val, LPWSTR buffer, UINT len )
1208 {
1209 return GetPrivateProfileStringW( section, entry, def_val,
1210 buffer, len, wininiW );
1211 }
1212
1213 /***********************************************************************
1214 * WriteProfileStringA (KERNEL32.@)
1215 */
1216 BOOL WINAPI WriteProfileStringA( LPCSTR section, LPCSTR entry,
1217 LPCSTR string )
1218 {
1219 return WritePrivateProfileStringA( section, entry, string, "win.ini" );
1220 }
1221
1222 /***********************************************************************
1223 * WriteProfileStringW (KERNEL32.@)
1224 */
1225 BOOL WINAPI WriteProfileStringW( LPCWSTR section, LPCWSTR entry,
1226 LPCWSTR string )
1227 {
1228 return WritePrivateProfileStringW( section, entry, string, wininiW );
1229 }
1230
1231
1232 /***********************************************************************
1233 * GetPrivateProfileIntW (KERNEL32.@)
1234 */
1235 UINT WINAPI GetPrivateProfileIntW( LPCWSTR section, LPCWSTR entry,
1236 INT def_val, LPCWSTR filename )
1237 {
1238 WCHAR buffer[30];
1239 UNICODE_STRING bufferW;
1240 INT len;
1241 ULONG result;
1242
1243 if (!(len = GetPrivateProfileStringW( section, entry, emptystringW,
1244 buffer, sizeof(buffer)/sizeof(WCHAR),
1245 filename )))
1246 return def_val;
1247
1248 /* FIXME: if entry can be found but it's empty, then Win16 is
1249 * supposed to return 0 instead of def_val ! Difficult/problematic
1250 * to implement (every other failure also returns zero buffer),
1251 * thus wait until testing framework avail for making sure nothing
1252 * else gets broken that way. */
1253 if (!buffer[0]) return (UINT)def_val;
1254
1255 RtlInitUnicodeString( &bufferW, buffer );
1256 RtlUnicodeStringToInteger( &bufferW, 0, &result);
1257 return result;
1258 }
1259
1260 /***********************************************************************
1261 * GetPrivateProfileIntA (KERNEL32.@)
1262 *
1263 * FIXME: rewrite using unicode
1264 */
1265 UINT WINAPI GetPrivateProfileIntA( LPCSTR section, LPCSTR entry,
1266 INT def_val, LPCSTR filename )
1267 {
1268 UNICODE_STRING entryW, filenameW, sectionW;
1269 UINT res;
1270 if(entry) RtlCreateUnicodeStringFromAsciiz(&entryW, entry);
1271 else entryW.Buffer = NULL;
1272 if(filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1273 else filenameW.Buffer = NULL;
1274 if(section) RtlCreateUnicodeStringFromAsciiz(&sectionW, section);
1275 else sectionW.Buffer = NULL;
1276 res = GetPrivateProfileIntW(sectionW.Buffer, entryW.Buffer, def_val,
1277 filenameW.Buffer);
1278 RtlFreeUnicodeString(&sectionW);
1279 RtlFreeUnicodeString(&filenameW);
1280 RtlFreeUnicodeString(&entryW);
1281 return res;
1282 }
1283
1284 /***********************************************************************
1285 * GetPrivateProfileSectionW (KERNEL32.@)
1286 */
1287 INT WINAPI GetPrivateProfileSectionW( LPCWSTR section, LPWSTR buffer,
1288 DWORD len, LPCWSTR filename )
1289 {
1290 int ret = 0;
1291
1292 if (!section || !buffer)
1293 {
1294 SetLastError(ERROR_INVALID_PARAMETER);
1295 return 0;
1296 }
1297
1298 TRACE("(%s, %p, %d, %s)\n", debugstr_w(section), buffer, len, debugstr_w(filename));
1299
1300 RtlEnterCriticalSection( &PROFILE_CritSect );
1301
1302 if (PROFILE_Open( filename, FALSE ))
1303 ret = PROFILE_GetSection(CurProfile->section, section, buffer, len, TRUE);
1304
1305 RtlLeaveCriticalSection( &PROFILE_CritSect );
1306
1307 return ret;
1308 }
1309
1310 /***********************************************************************
1311 * GetPrivateProfileSectionA (KERNEL32.@)
1312 */
1313 INT WINAPI GetPrivateProfileSectionA( LPCSTR section, LPSTR buffer,
1314 DWORD len, LPCSTR filename )
1315 {
1316 UNICODE_STRING sectionW, filenameW;
1317 LPWSTR bufferW;
1318 INT retW, ret = 0;
1319
1320 if (!section || !buffer)
1321 {
1322 SetLastError(ERROR_INVALID_PARAMETER);
1323 return 0;
1324 }
1325
1326 bufferW = HeapAlloc(GetProcessHeap(), 0, len * 2 * sizeof(WCHAR));
1327 RtlCreateUnicodeStringFromAsciiz(&sectionW, section);
1328 if (filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1329 else filenameW.Buffer = NULL;
1330
1331 retW = GetPrivateProfileSectionW(sectionW.Buffer, bufferW, len * 2, filenameW.Buffer);
1332 if (retW)
1333 {
1334 if (retW == len * 2 - 2) retW++; /* overflow */
1335 ret = WideCharToMultiByte(CP_ACP, 0, bufferW, retW + 1, buffer, len, NULL, NULL);
1336 if (!ret || ret == len) /* overflow */
1337 {
1338 ret = len - 2;
1339 buffer[len-2] = 0;
1340 buffer[len-1] = 0;
1341 }
1342 else ret--;
1343 }
1344 else
1345 {
1346 buffer[0] = 0;
1347 buffer[1] = 0;
1348 }
1349
1350 RtlFreeUnicodeString(&sectionW);
1351 RtlFreeUnicodeString(&filenameW);
1352 HeapFree(GetProcessHeap(), 0, bufferW);
1353 return ret;
1354 }
1355
1356 /***********************************************************************
1357 * GetProfileSectionA (KERNEL32.@)
1358 */
1359 INT WINAPI GetProfileSectionA( LPCSTR section, LPSTR buffer, DWORD len )
1360 {
1361 return GetPrivateProfileSectionA( section, buffer, len, "win.ini" );
1362 }
1363
1364 /***********************************************************************
1365 * GetProfileSectionW (KERNEL32.@)
1366 */
1367 INT WINAPI GetProfileSectionW( LPCWSTR section, LPWSTR buffer, DWORD len )
1368 {
1369 return GetPrivateProfileSectionW( section, buffer, len, wininiW );
1370 }
1371
1372
1373 /***********************************************************************
1374 * WritePrivateProfileStringW (KERNEL32.@)
1375 */
1376 BOOL WINAPI WritePrivateProfileStringW( LPCWSTR section, LPCWSTR entry,
1377 LPCWSTR string, LPCWSTR filename )
1378 {
1379 BOOL ret = FALSE;
1380
1381 RtlEnterCriticalSection( &PROFILE_CritSect );
1382
1383 if (!section && !entry && !string) /* documented "file flush" case */
1384 {
1385 if (!filename || PROFILE_Open( filename, TRUE ))
1386 {
1387 if (CurProfile) PROFILE_ReleaseFile(); /* always return FALSE in this case */
1388 }
1389 }
1390 else if (PROFILE_Open( filename, TRUE ))
1391 {
1392 if (!section) {
1393 SetLastError(ERROR_FILE_NOT_FOUND);
1394 } else {
1395 ret = PROFILE_SetString( section, entry, string, FALSE);
1396 PROFILE_FlushFile();
1397 }
1398 }
1399
1400 RtlLeaveCriticalSection( &PROFILE_CritSect );
1401 return ret;
1402 }
1403
1404 /***********************************************************************
1405 * WritePrivateProfileStringA (KERNEL32.@)
1406 */
1407 BOOL WINAPI WritePrivateProfileStringA( LPCSTR section, LPCSTR entry,
1408 LPCSTR string, LPCSTR filename )
1409 {
1410 UNICODE_STRING sectionW, entryW, stringW, filenameW;
1411 BOOL ret;
1412
1413 if (section) RtlCreateUnicodeStringFromAsciiz(&sectionW, section);
1414 else sectionW.Buffer = NULL;
1415 if (entry) RtlCreateUnicodeStringFromAsciiz(&entryW, entry);
1416 else entryW.Buffer = NULL;
1417 if (string) RtlCreateUnicodeStringFromAsciiz(&stringW, string);
1418 else stringW.Buffer = NULL;
1419 if (filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1420 else filenameW.Buffer = NULL;
1421
1422 ret = WritePrivateProfileStringW(sectionW.Buffer, entryW.Buffer,
1423 stringW.Buffer, filenameW.Buffer);
1424 RtlFreeUnicodeString(&sectionW);
1425 RtlFreeUnicodeString(&entryW);
1426 RtlFreeUnicodeString(&stringW);
1427 RtlFreeUnicodeString(&filenameW);
1428 return ret;
1429 }
1430
1431 /***********************************************************************
1432 * WritePrivateProfileSectionW (KERNEL32.@)
1433 */
1434 BOOL WINAPI WritePrivateProfileSectionW( LPCWSTR section,
1435 LPCWSTR string, LPCWSTR filename )
1436 {
1437 BOOL ret = FALSE;
1438 LPWSTR p;
1439
1440 RtlEnterCriticalSection( &PROFILE_CritSect );
1441
1442 if (!section && !string)
1443 {
1444 if (!filename || PROFILE_Open( filename, TRUE ))
1445 {
1446 if (CurProfile) PROFILE_ReleaseFile(); /* always return FALSE in this case */
1447 }
1448 }
1449 else if (PROFILE_Open( filename, TRUE )) {
1450 if (!string) {/* delete the named section*/
1451 ret = PROFILE_SetString(section,NULL,NULL, FALSE);
1452 PROFILE_FlushFile();
1453 } else {
1454 PROFILE_DeleteAllKeys(section);
1455 ret = TRUE;
1456 while(*string) {
1457 LPWSTR buf = HeapAlloc( GetProcessHeap(), 0, (strlenW(string)+1) * sizeof(WCHAR) );
1458 strcpyW( buf, string );
1459 if((p = strchrW( buf, '='))) {
1460 *p='\0';
1461 ret = PROFILE_SetString( section, buf, p+1, TRUE);
1462 }
1463 HeapFree( GetProcessHeap(), 0, buf );
1464 string += strlenW(string)+1;
1465 }
1466 PROFILE_FlushFile();
1467 }
1468 }
1469
1470 RtlLeaveCriticalSection( &PROFILE_CritSect );
1471 return ret;
1472 }
1473
1474 /***********************************************************************
1475 * WritePrivateProfileSectionA (KERNEL32.@)
1476 */
1477 BOOL WINAPI WritePrivateProfileSectionA( LPCSTR section,
1478 LPCSTR string, LPCSTR filename)
1479
1480 {
1481 UNICODE_STRING sectionW, filenameW;
1482 LPWSTR stringW;
1483 BOOL ret;
1484
1485 if (string)
1486 {
1487 INT lenA, lenW;
1488 LPCSTR p = string;
1489
1490 while(*p) p += strlen(p) + 1;
1491 lenA = p - string + 1;
1492 lenW = MultiByteToWideChar(CP_ACP, 0, string, lenA, NULL, 0);
1493 if ((stringW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR))))
1494 MultiByteToWideChar(CP_ACP, 0, string, lenA, stringW, lenW);
1495 }
1496 else stringW = NULL;
1497 if (section) RtlCreateUnicodeStringFromAsciiz(&sectionW, section);
1498 else sectionW.Buffer = NULL;
1499 if (filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1500 else filenameW.Buffer = NULL;
1501
1502 ret = WritePrivateProfileSectionW(sectionW.Buffer, stringW, filenameW.Buffer);
1503
1504 HeapFree(GetProcessHeap(), 0, stringW);
1505 RtlFreeUnicodeString(&sectionW);
1506 RtlFreeUnicodeString(&filenameW);
1507 return ret;
1508 }
1509
1510 /***********************************************************************
1511 * WriteProfileSectionA (KERNEL32.@)
1512 */
1513 BOOL WINAPI WriteProfileSectionA( LPCSTR section, LPCSTR keys_n_values)
1514
1515 {
1516 return WritePrivateProfileSectionA( section, keys_n_values, "win.ini");
1517 }
1518
1519 /***********************************************************************
1520 * WriteProfileSectionW (KERNEL32.@)
1521 */
1522 BOOL WINAPI WriteProfileSectionW( LPCWSTR section, LPCWSTR keys_n_values)
1523 {
1524 return WritePrivateProfileSectionW(section, keys_n_values, wininiW);
1525 }
1526
1527
1528 /***********************************************************************
1529 * GetPrivateProfileSectionNamesW (KERNEL32.@)
1530 *
1531 * Returns the section names contained in the specified file.
1532 * FIXME: Where do we find this file when the path is relative?
1533 * The section names are returned as a list of strings with an extra
1534 * '\0' to mark the end of the list. Except for that the behavior
1535 * depends on the Windows version.
1536 *
1537 * Win95:
1538 * - if the buffer is 0 or 1 character long then it is as if it was of
1539 * infinite length.
1540 * - otherwise, if the buffer is too small only the section names that fit
1541 * are returned.
1542 * - note that this means if the buffer was too small to return even just
1543 * the first section name then a single '\0' will be returned.
1544 * - the return value is the number of characters written in the buffer,
1545 * except if the buffer was too small in which case len-2 is returned
1546 *
1547 * Win2000:
1548 * - if the buffer is 0, 1 or 2 characters long then it is filled with
1549 * '\0' and the return value is 0
1550 * - otherwise if the buffer is too small then the first section name that
1551 * does not fit is truncated so that the string list can be terminated
1552 * correctly (double '\0')
1553 * - the return value is the number of characters written in the buffer
1554 * except for the trailing '\0'. If the buffer is too small, then the
1555 * return value is len-2
1556 * - Win2000 has a bug that triggers when the section names and the
1557 * trailing '\0' fit exactly in the buffer. In that case the trailing
1558 * '\0' is missing.
1559 *
1560 * Wine implements the observed Win2000 behavior (except for the bug).
1561 *
1562 * Note that when the buffer is big enough then the return value may be any
1563 * value between 1 and len-1 (or len in Win95), including len-2.
1564 */
1565 DWORD WINAPI GetPrivateProfileSectionNamesW( LPWSTR buffer, DWORD size,
1566 LPCWSTR filename)
1567 {
1568 DWORD ret = 0;
1569
1570 RtlEnterCriticalSection( &PROFILE_CritSect );
1571
1572 if (PROFILE_Open( filename, FALSE ))
1573 ret = PROFILE_GetSectionNames(buffer, size);
1574
1575 RtlLeaveCriticalSection( &PROFILE_CritSect );
1576
1577 return ret;
1578 }
1579
1580
1581 /***********************************************************************
1582 * GetPrivateProfileSectionNamesA (KERNEL32.@)
1583 */
1584 DWORD WINAPI GetPrivateProfileSectionNamesA( LPSTR buffer, DWORD size,
1585 LPCSTR filename)
1586 {
1587 UNICODE_STRING filenameW;
1588 LPWSTR bufferW;
1589 INT retW, ret = 0;
1590
1591 bufferW = buffer ? HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR)) : NULL;
1592 if (filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1593 else filenameW.Buffer = NULL;
1594
1595 retW = GetPrivateProfileSectionNamesW(bufferW, size, filenameW.Buffer);
1596 if (retW && size)
1597 {
1598 ret = WideCharToMultiByte(CP_ACP, 0, bufferW, retW+1, buffer, size-1, NULL, NULL);
1599 if (!ret)
1600 {
1601 ret = size-2;
1602 buffer[size-1] = 0;
1603 }
1604 else
1605 ret = ret-1;
1606 }
1607 else if(size)
1608 buffer[0] = '\0';
1609
1610 RtlFreeUnicodeString(&filenameW);
1611 HeapFree(GetProcessHeap(), 0, bufferW);
1612 return ret;
1613 }
1614
1615 /***********************************************************************
1616 * GetPrivateProfileStructW (KERNEL32.@)
1617 *
1618 * Should match Win95's behaviour pretty much
1619 */
1620 BOOL WINAPI GetPrivateProfileStructW (LPCWSTR section, LPCWSTR key,
1621 LPVOID buf, UINT len, LPCWSTR filename)
1622 {
1623 BOOL ret = FALSE;
1624
1625 RtlEnterCriticalSection( &PROFILE_CritSect );
1626
1627 if (PROFILE_Open( filename, FALSE )) {
1628 PROFILEKEY *k = PROFILE_Find ( &CurProfile->section, section, key, FALSE, FALSE);
1629 if (k) {
1630 TRACE("value (at %p): %s\n", k->value, debugstr_w(k->value));
1631 if (((strlenW(k->value) - 2) / 2) == len)
1632 {
1633 LPWSTR end, p;
1634 BOOL valid = TRUE;
1635 WCHAR c;
1636 DWORD chksum = 0;
1637
1638 end = k->value + strlenW(k->value); /* -> '\0' */
1639 /* check for invalid chars in ASCII coded hex string */
1640 for (p=k->value; p < end; p++)
1641 {
1642 if (!isxdigitW(*p))
1643 {
1644 WARN("invalid char '%x' in file %s->[%s]->%s !\n",
1645 *p, debugstr_w(filename), debugstr_w(section), debugstr_w(key));
1646 valid = FALSE;
1647 break;
1648 }
1649 }
1650 if (valid)
1651 {
1652 BOOL highnibble = TRUE;
1653 BYTE b = 0, val;
1654 LPBYTE binbuf = buf;
1655
1656 end -= 2; /* don't include checksum in output data */
1657 /* translate ASCII hex format into binary data */
1658 for (p=k->value; p < end; p++)
1659 {
1660 c = toupperW(*p);
1661 val = (c > '9') ?
1662 (c - 'A' + 10) : (c - '0');
1663
1664 if (highnibble)
1665 b = val << 4;
1666 else
1667 {
1668 b += val;
1669 *binbuf++ = b; /* feed binary data into output */
1670 chksum += b; /* calculate checksum */
1671 }
1672 highnibble ^= 1; /* toggle */
1673 }
1674 /* retrieve stored checksum value */
1675 c = toupperW(*p++);
1676 b = ( (c > '9') ? (c - 'A' + 10) : (c - '0') ) << 4;
1677 c = toupperW(*p);
1678 b += (c > '9') ? (c - 'A' + 10) : (c - '0');
1679 if (b == (chksum & 0xff)) /* checksums match ? */
1680 ret = TRUE;
1681 }
1682 }
1683 }
1684 }
1685 RtlLeaveCriticalSection( &PROFILE_CritSect );
1686
1687 return ret;
1688 }
1689
1690 /***********************************************************************
1691 * GetPrivateProfileStructA (KERNEL32.@)
1692 */
1693 BOOL WINAPI GetPrivateProfileStructA (LPCSTR section, LPCSTR key,
1694 LPVOID buffer, UINT len, LPCSTR filename)
1695 {
1696 UNICODE_STRING sectionW, keyW, filenameW;
1697 INT ret;
1698
1699 if (section) RtlCreateUnicodeStringFromAsciiz(&sectionW, section);
1700 else sectionW.Buffer = NULL;
1701 if (key) RtlCreateUnicodeStringFromAsciiz(&keyW, key);
1702 else keyW.Buffer = NULL;
1703 if (filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1704 else filenameW.Buffer = NULL;
1705
1706 ret = GetPrivateProfileStructW(sectionW.Buffer, keyW.Buffer, buffer, len,
1707 filenameW.Buffer);
1708 /* Do not translate binary data. */
1709
1710 RtlFreeUnicodeString(&sectionW);
1711 RtlFreeUnicodeString(&keyW);
1712 RtlFreeUnicodeString(&filenameW);
1713 return ret;
1714 }
1715
1716
1717
1718 /***********************************************************************
1719 * WritePrivateProfileStructW (KERNEL32.@)
1720 */
1721 BOOL WINAPI WritePrivateProfileStructW (LPCWSTR section, LPCWSTR key,
1722 LPVOID buf, UINT bufsize, LPCWSTR filename)
1723 {
1724 BOOL ret = FALSE;
1725 LPBYTE binbuf;
1726 LPWSTR outstring, p;
1727 DWORD sum = 0;
1728
1729 if (!section && !key && !buf) /* flush the cache */
1730 return WritePrivateProfileStringW( NULL, NULL, NULL, filename );
1731
1732 /* allocate string buffer for hex chars + checksum hex char + '\0' */
1733 outstring = HeapAlloc( GetProcessHeap(), 0, (bufsize*2 + 2 + 1) * sizeof(WCHAR) );
1734 p = outstring;
1735 for (binbuf = (LPBYTE)buf; binbuf < (LPBYTE)buf+bufsize; binbuf++) {
1736 *p++ = hex[*binbuf >> 4];
1737 *p++ = hex[*binbuf & 0xf];
1738 sum += *binbuf;
1739 }
1740 /* checksum is sum & 0xff */
1741 *p++ = hex[(sum & 0xf0) >> 4];
1742 *p++ = hex[sum & 0xf];
1743 *p++ = '\0';
1744
1745 RtlEnterCriticalSection( &PROFILE_CritSect );
1746
1747 if (PROFILE_Open( filename, TRUE )) {
1748 ret = PROFILE_SetString( section, key, outstring, FALSE);
1749 PROFILE_FlushFile();
1750 }
1751
1752 RtlLeaveCriticalSection( &PROFILE_CritSect );
1753
1754 HeapFree( GetProcessHeap(), 0, outstring );
1755
1756 return ret;
1757 }
1758
1759 /***********************************************************************
1760 * WritePrivateProfileStructA (KERNEL32.@)
1761 */
1762 BOOL WINAPI WritePrivateProfileStructA (LPCSTR section, LPCSTR key,
1763 LPVOID buf, UINT bufsize, LPCSTR filename)
1764 {
1765 UNICODE_STRING sectionW, keyW, filenameW;
1766 INT ret;
1767
1768 if (section) RtlCreateUnicodeStringFromAsciiz(&sectionW, section);
1769 else sectionW.Buffer = NULL;
1770 if (key) RtlCreateUnicodeStringFromAsciiz(&keyW, key);
1771 else keyW.Buffer = NULL;
1772 if (filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
1773 else filenameW.Buffer = NULL;
1774
1775 /* Do not translate binary data. */
1776 ret = WritePrivateProfileStructW(sectionW.Buffer, keyW.Buffer, buf, bufsize,
1777 filenameW.Buffer);
1778
1779 RtlFreeUnicodeString(&sectionW);
1780 RtlFreeUnicodeString(&keyW);
1781 RtlFreeUnicodeString(&filenameW);
1782 return ret;
1783 }
1784
1785
1786 /***********************************************************************
1787 * OpenProfileUserMapping (KERNEL32.@)
1788 */
1789 BOOL WINAPI OpenProfileUserMapping(void) {
1790 FIXME("(), stub!\n");
1791 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1792 return FALSE;
1793 }
1794
1795 /***********************************************************************
1796 * CloseProfileUserMapping (KERNEL32.@)
1797 */
1798 BOOL WINAPI CloseProfileUserMapping(void) {
1799 FIXME("(), stub!\n");
1800 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1801 return FALSE;
1802 }
Maarten's multimedia branch