wined3d: Don't warn about independent color write masks when the masks are all the...
[wine] / dlls / credui / credui_main.c
1 /*
2  * Credentials User Interface
3  *
4  * Copyright 2006 Robert Shearman (for CodeWeavers)
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include <stdarg.h>
22
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winnt.h"
26 #include "winuser.h"
27 #include "wincred.h"
28 #include "commctrl.h"
29
30 #include "credui_resources.h"
31
32 #include "wine/debug.h"
33 #include "wine/unicode.h"
34 #include "wine/list.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(credui);
37
38 #define TOOLID_INCORRECTPASSWORD    1
39 #define TOOLID_CAPSLOCKON           2
40
41 #define ID_CAPSLOCKPOP              1
42
43 struct pending_credentials
44 {
45     struct list entry;
46     PWSTR pszTargetName;
47     PWSTR pszUsername;
48     PWSTR pszPassword;
49     BOOL generic;
50 };
51
52 static HINSTANCE hinstCredUI;
53
54 static struct list pending_credentials_list = LIST_INIT(pending_credentials_list);
55
56 static CRITICAL_SECTION csPendingCredentials;
57 static CRITICAL_SECTION_DEBUG critsect_debug =
58 {
59     0, 0, &csPendingCredentials,
60     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
61     0, 0, { (DWORD_PTR)(__FILE__ ": csPendingCredentials") }
62 };
63 static CRITICAL_SECTION csPendingCredentials = { &critsect_debug, -1, 0, 0, 0, 0 };
64
65
66 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
67 {
68     TRACE("(0x%p, %d, %p)\n",hinstDLL,fdwReason,lpvReserved);
69
70     if (fdwReason == DLL_WINE_PREATTACH) return FALSE;  /* prefer native version */
71
72     if (fdwReason == DLL_PROCESS_ATTACH)
73     {
74         DisableThreadLibraryCalls(hinstDLL);
75         hinstCredUI = hinstDLL;
76         InitCommonControls();
77     }
78     else if (fdwReason == DLL_PROCESS_DETACH)
79     {
80         struct pending_credentials *entry, *cursor2;
81         LIST_FOR_EACH_ENTRY_SAFE(entry, cursor2, &pending_credentials_list, struct pending_credentials, entry)
82         {
83             list_remove(&entry->entry);
84
85             HeapFree(GetProcessHeap(), 0, entry->pszTargetName);
86             HeapFree(GetProcessHeap(), 0, entry->pszUsername);
87             ZeroMemory(entry->pszPassword, (strlenW(entry->pszPassword) + 1) * sizeof(WCHAR));
88             HeapFree(GetProcessHeap(), 0, entry->pszPassword);
89             HeapFree(GetProcessHeap(), 0, entry);
90         }
91     }
92
93     return TRUE;
94 }
95
96 static DWORD save_credentials(PCWSTR pszTargetName, PCWSTR pszUsername,
97                               PCWSTR pszPassword, BOOL generic)
98 {
99     CREDENTIALW cred;
100
101     TRACE("saving servername %s with username %s\n", debugstr_w(pszTargetName), debugstr_w(pszUsername));
102
103     cred.Flags = 0;
104     cred.Type = generic ? CRED_TYPE_GENERIC : CRED_TYPE_DOMAIN_PASSWORD;
105     cred.TargetName = (LPWSTR)pszTargetName;
106     cred.Comment = NULL;
107     cred.CredentialBlobSize = strlenW(pszPassword) * sizeof(WCHAR);
108     cred.CredentialBlob = (LPBYTE)pszPassword;
109     cred.Persist = CRED_PERSIST_ENTERPRISE;
110     cred.AttributeCount = 0;
111     cred.Attributes = NULL;
112     cred.TargetAlias = NULL;
113     cred.UserName = (LPWSTR)pszUsername;
114
115     if (CredWriteW(&cred, 0))
116         return ERROR_SUCCESS;
117     else
118     {
119         DWORD ret = GetLastError();
120         ERR("CredWriteW failed with error %d\n", ret);
121         return ret;
122     }
123 }
124
125 struct cred_dialog_params
126 {
127     PCWSTR pszTargetName;
128     PCWSTR pszMessageText;
129     PCWSTR pszCaptionText;
130     HBITMAP hbmBanner;
131     PWSTR pszUsername;
132     ULONG ulUsernameMaxChars;
133     PWSTR pszPassword;
134     ULONG ulPasswordMaxChars;
135     BOOL fSave;
136     DWORD dwFlags;
137     HWND hwndBalloonTip;
138     BOOL fBalloonTipActive;
139 };
140
141 static void CredDialogFillUsernameCombo(HWND hwndUsername, const struct cred_dialog_params *params)
142 {
143     DWORD count;
144     DWORD i;
145     PCREDENTIALW *credentials;
146
147     if (!CredEnumerateW(NULL, 0, &count, &credentials))
148         return;
149
150     for (i = 0; i < count; i++)
151     {
152         COMBOBOXEXITEMW comboitem;
153         DWORD j;
154         BOOL duplicate = FALSE;
155
156         if (params->dwFlags & CREDUI_FLAGS_GENERIC_CREDENTIALS)
157         {
158             if ((credentials[i]->Type != CRED_TYPE_GENERIC) || !credentials[i]->UserName)
159                 continue;
160         }
161         else
162         {
163             if (credentials[i]->Type == CRED_TYPE_GENERIC)
164                 continue;
165         }
166
167         /* don't add another item with the same name if we've already added it */
168         for (j = 0; j < i; j++)
169             if (!strcmpW(credentials[i]->UserName, credentials[j]->UserName))
170             {
171                 duplicate = TRUE;
172                 break;
173             }
174
175         if (duplicate)
176             continue;
177
178         comboitem.mask = CBEIF_TEXT;
179         comboitem.iItem = -1;
180         comboitem.pszText = credentials[i]->UserName;
181         SendMessageW(hwndUsername, CBEM_INSERTITEMW, 0, (LPARAM)&comboitem);
182     }
183
184     CredFree(credentials);
185 }
186
187 static void CredDialogCreateBalloonTip(HWND hwndDlg, struct cred_dialog_params *params)
188 {
189     TTTOOLINFOW toolinfo;
190     WCHAR wszText[256];
191
192     if (params->hwndBalloonTip)
193         return;
194
195     params->hwndBalloonTip = CreateWindowExW(WS_EX_TOOLWINDOW, TOOLTIPS_CLASSW,
196         NULL, WS_POPUP | TTS_NOPREFIX | TTS_BALLOON, CW_USEDEFAULT,
197         CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, hwndDlg, NULL,
198         hinstCredUI, NULL);
199     SetWindowPos(params->hwndBalloonTip, HWND_TOPMOST, 0, 0, 0, 0,
200                  SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
201
202     if (!LoadStringW(hinstCredUI, IDS_INCORRECTPASSWORD, wszText, sizeof(wszText)/sizeof(wszText[0])))
203     {
204         ERR("failed to load IDS_INCORRECTPASSWORD\n");
205         return;
206     }
207
208     toolinfo.cbSize = sizeof(toolinfo);
209     toolinfo.uFlags = TTF_TRACK;
210     toolinfo.hwnd = hwndDlg;
211     toolinfo.uId = TOOLID_INCORRECTPASSWORD;
212     memset(&toolinfo.rect, 0, sizeof(toolinfo.rect));
213     toolinfo.hinst = NULL;
214     toolinfo.lpszText = wszText;
215     toolinfo.lParam = 0;
216     toolinfo.lpReserved = NULL;
217     SendMessageW(params->hwndBalloonTip, TTM_ADDTOOLW, 0, (LPARAM)&toolinfo);
218
219     if (!LoadStringW(hinstCredUI, IDS_CAPSLOCKON, wszText, sizeof(wszText)/sizeof(wszText[0])))
220     {
221         ERR("failed to load IDS_CAPSLOCKON\n");
222         return;
223     }
224
225     toolinfo.uId = TOOLID_CAPSLOCKON;
226     SendMessageW(params->hwndBalloonTip, TTM_ADDTOOLW, 0, (LPARAM)&toolinfo);
227 }
228
229 static void CredDialogShowIncorrectPasswordBalloon(HWND hwndDlg, struct cred_dialog_params *params)
230 {
231     TTTOOLINFOW toolinfo;
232     RECT rcPassword;
233     INT x;
234     INT y;
235     WCHAR wszTitle[256];
236
237     /* user name likely wrong so balloon would be confusing. focus is also
238      * not set to the password edit box, so more notification would need to be
239      * handled */
240     if (!params->pszUsername[0])
241         return;
242
243     /* don't show two balloon tips at once */
244     if (params->fBalloonTipActive)
245         return;
246
247     if (!LoadStringW(hinstCredUI, IDS_INCORRECTPASSWORDTITLE, wszTitle, sizeof(wszTitle)/sizeof(wszTitle[0])))
248     {
249         ERR("failed to load IDS_INCORRECTPASSWORDTITLE\n");
250         return;
251     }
252
253     CredDialogCreateBalloonTip(hwndDlg, params);
254
255     memset(&toolinfo, 0, sizeof(toolinfo));
256     toolinfo.cbSize = sizeof(toolinfo);
257     toolinfo.hwnd = hwndDlg;
258     toolinfo.uId = TOOLID_INCORRECTPASSWORD;
259
260     SendMessageW(params->hwndBalloonTip, TTM_SETTITLEW, TTI_ERROR, (LPARAM)wszTitle);
261
262     GetWindowRect(GetDlgItem(hwndDlg, IDC_PASSWORD), &rcPassword);
263     /* centred vertically and in the right side of the password edit control */
264     x = rcPassword.right - 12;
265     y = (rcPassword.top + rcPassword.bottom) / 2;
266     SendMessageW(params->hwndBalloonTip, TTM_TRACKPOSITION, 0, MAKELONG(x, y));
267
268     SendMessageW(params->hwndBalloonTip, TTM_TRACKACTIVATE, TRUE, (LPARAM)&toolinfo);
269
270     params->fBalloonTipActive = TRUE;
271 }
272
273 static void CredDialogShowCapsLockBalloon(HWND hwndDlg, struct cred_dialog_params *params)
274 {
275     TTTOOLINFOW toolinfo;
276     RECT rcPassword;
277     INT x;
278     INT y;
279     WCHAR wszTitle[256];
280
281     /* don't show two balloon tips at once */
282     if (params->fBalloonTipActive)
283         return;
284
285     if (!LoadStringW(hinstCredUI, IDS_CAPSLOCKONTITLE, wszTitle, sizeof(wszTitle)/sizeof(wszTitle[0])))
286     {
287         ERR("failed to load IDS_IDSCAPSLOCKONTITLE\n");
288         return;
289     }
290
291     CredDialogCreateBalloonTip(hwndDlg, params);
292
293     memset(&toolinfo, 0, sizeof(toolinfo));
294     toolinfo.cbSize = sizeof(toolinfo);
295     toolinfo.hwnd = hwndDlg;
296     toolinfo.uId = TOOLID_CAPSLOCKON;
297
298     SendMessageW(params->hwndBalloonTip, TTM_SETTITLEW, TTI_WARNING, (LPARAM)wszTitle);
299
300     GetWindowRect(GetDlgItem(hwndDlg, IDC_PASSWORD), &rcPassword);
301     /* just inside the left side of the password edit control */
302     x = rcPassword.left + 12;
303     y = rcPassword.bottom - 3;
304     SendMessageW(params->hwndBalloonTip, TTM_TRACKPOSITION, 0, MAKELONG(x, y));
305
306     SendMessageW(params->hwndBalloonTip, TTM_TRACKACTIVATE, TRUE, (LPARAM)&toolinfo);
307
308     SetTimer(hwndDlg, ID_CAPSLOCKPOP,
309              SendMessageW(params->hwndBalloonTip, TTM_GETDELAYTIME, TTDT_AUTOPOP, 0),
310              NULL);
311
312     params->fBalloonTipActive = TRUE;
313 }
314
315 static void CredDialogHideBalloonTip(HWND hwndDlg, struct cred_dialog_params *params)
316 {
317     TTTOOLINFOW toolinfo;
318
319     if (!params->hwndBalloonTip)
320         return;
321
322     memset(&toolinfo, 0, sizeof(toolinfo));
323
324     toolinfo.cbSize = sizeof(toolinfo);
325     toolinfo.hwnd = hwndDlg;
326     toolinfo.uId = 0;
327     SendMessageW(params->hwndBalloonTip, TTM_TRACKACTIVATE, FALSE, (LPARAM)&toolinfo);
328     toolinfo.uId = 1;
329     SendMessageW(params->hwndBalloonTip, TTM_TRACKACTIVATE, FALSE, (LPARAM)&toolinfo);
330
331     params->fBalloonTipActive = FALSE;
332 }
333
334 static inline BOOL CredDialogCapsLockOn(void)
335 {
336     return GetKeyState(VK_CAPITAL) & 0x1 ? TRUE : FALSE;
337 }
338
339 static LRESULT CALLBACK CredDialogPasswordSubclassProc(HWND hwnd, UINT uMsg,
340     WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
341 {
342     struct cred_dialog_params *params = (struct cred_dialog_params *)dwRefData;
343     switch (uMsg)
344     {
345     case WM_KEYDOWN:
346         if (wParam == VK_CAPITAL)
347         {
348             HWND hwndDlg = GetParent(hwnd);
349             if (CredDialogCapsLockOn())
350                 CredDialogShowCapsLockBalloon(hwndDlg, params);
351             else
352                 CredDialogHideBalloonTip(hwndDlg, params);
353         }
354         break;
355     case WM_DESTROY:
356         RemoveWindowSubclass(hwnd, CredDialogPasswordSubclassProc, uIdSubclass);
357         break;
358     }
359     return DefSubclassProc(hwnd, uMsg, wParam, lParam);
360 }
361
362 static BOOL CredDialogInit(HWND hwndDlg, struct cred_dialog_params *params)
363 {
364     HWND hwndUsername = GetDlgItem(hwndDlg, IDC_USERNAME);
365     HWND hwndPassword = GetDlgItem(hwndDlg, IDC_PASSWORD);
366
367     SetWindowLongPtrW(hwndDlg, DWLP_USER, (LONG_PTR)params);
368
369     if (params->hbmBanner)
370         SendMessageW(GetDlgItem(hwndDlg, IDB_BANNER), STM_SETIMAGE,
371                      IMAGE_BITMAP, (LPARAM)params->hbmBanner);
372
373     if (params->pszMessageText)
374         SetDlgItemTextW(hwndDlg, IDC_MESSAGE, params->pszMessageText);
375     else
376     {
377         WCHAR format[256];
378         WCHAR message[256];
379         LoadStringW(hinstCredUI, IDS_MESSAGEFORMAT, format, sizeof(format)/sizeof(format[0]));
380         snprintfW(message, sizeof(message)/sizeof(message[0]), format, params->pszTargetName);
381         SetDlgItemTextW(hwndDlg, IDC_MESSAGE, message);
382     }
383     SetWindowTextW(hwndUsername, params->pszUsername);
384     SetWindowTextW(hwndPassword, params->pszPassword);
385
386     CredDialogFillUsernameCombo(hwndUsername, params);
387
388     if (params->pszUsername[0])
389     {
390         /* prevent showing a balloon tip here */
391         params->fBalloonTipActive = TRUE;
392         SetFocus(hwndPassword);
393         params->fBalloonTipActive = FALSE;
394     }
395     else
396         SetFocus(hwndUsername);
397
398     if (params->pszCaptionText)
399         SetWindowTextW(hwndDlg, params->pszCaptionText);
400     else
401     {
402         WCHAR format[256];
403         WCHAR title[256];
404         LoadStringW(hinstCredUI, IDS_TITLEFORMAT, format, sizeof(format)/sizeof(format[0]));
405         snprintfW(title, sizeof(title)/sizeof(title[0]), format, params->pszTargetName);
406         SetWindowTextW(hwndDlg, title);
407     }
408
409     if (params->dwFlags & (CREDUI_FLAGS_DO_NOT_PERSIST|CREDUI_FLAGS_PERSIST))
410         ShowWindow(GetDlgItem(hwndDlg, IDC_SAVE), SW_HIDE);
411     else if (params->fSave)
412         CheckDlgButton(hwndDlg, IDC_SAVE, BST_CHECKED);
413
414     /* setup subclassing for Caps Lock detection */
415     SetWindowSubclass(hwndPassword, CredDialogPasswordSubclassProc, 1, (DWORD_PTR)params);
416
417     if (params->dwFlags & CREDUI_FLAGS_INCORRECT_PASSWORD)
418         CredDialogShowIncorrectPasswordBalloon(hwndDlg, params);
419     else if ((GetFocus() == hwndPassword) && CredDialogCapsLockOn())
420         CredDialogShowCapsLockBalloon(hwndDlg, params);
421
422     return FALSE;
423 }
424
425 static void CredDialogCommandOk(HWND hwndDlg, struct cred_dialog_params *params)
426 {
427     HWND hwndUsername = GetDlgItem(hwndDlg, IDC_USERNAME);
428     LPWSTR user;
429     INT len;
430     INT len2;
431
432     len = GetWindowTextLengthW(hwndUsername);
433     user = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
434     GetWindowTextW(hwndUsername, user, len + 1);
435
436     if (!user[0])
437     {
438         HeapFree(GetProcessHeap(), 0, user);
439         return;
440     }
441
442     if (!strchrW(user, '\\') && !strchrW(user, '@'))
443     {
444         ULONG len_target = strlenW(params->pszTargetName);
445         memcpy(params->pszUsername, params->pszTargetName,
446                min(len_target, params->ulUsernameMaxChars) * sizeof(WCHAR));
447         if (len_target + 1 < params->ulUsernameMaxChars)
448             params->pszUsername[len_target] = '\\';
449         if (len_target + 2 < params->ulUsernameMaxChars)
450             params->pszUsername[len_target + 1] = '\0';
451     }
452     else if (params->ulUsernameMaxChars > 0)
453         params->pszUsername[0] = '\0';
454
455     len2 = strlenW(params->pszUsername);
456     memcpy(params->pszUsername + len2, user, min(len, params->ulUsernameMaxChars - len2) * sizeof(WCHAR));
457     if (params->ulUsernameMaxChars)
458         params->pszUsername[len2 + min(len, params->ulUsernameMaxChars - len2 - 1)] = '\0';
459
460     HeapFree(GetProcessHeap(), 0, user);
461
462     GetDlgItemTextW(hwndDlg, IDC_PASSWORD, params->pszPassword,
463                     params->ulPasswordMaxChars);
464
465     params->fSave = IsDlgButtonChecked(hwndDlg, IDC_SAVE) == BST_CHECKED;
466
467     EndDialog(hwndDlg, IDOK);
468 }
469
470 static INT_PTR CALLBACK CredDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,
471                                        LPARAM lParam)
472 {
473     switch (uMsg)
474     {
475         case WM_INITDIALOG:
476         {
477             struct cred_dialog_params *params = (struct cred_dialog_params *)lParam;
478
479             return CredDialogInit(hwndDlg, params);
480         }
481         case WM_COMMAND:
482             switch (wParam)
483             {
484                 case MAKELONG(IDOK, BN_CLICKED):
485                 {
486                     struct cred_dialog_params *params =
487                         (struct cred_dialog_params *)GetWindowLongPtrW(hwndDlg, DWLP_USER);
488                     CredDialogCommandOk(hwndDlg, params);
489                     return TRUE;
490                 }
491                 case MAKELONG(IDCANCEL, BN_CLICKED):
492                     EndDialog(hwndDlg, IDCANCEL);
493                     return TRUE;
494                 case MAKELONG(IDC_PASSWORD, EN_SETFOCUS):
495                     if (CredDialogCapsLockOn())
496                     {
497                         struct cred_dialog_params *params =
498                             (struct cred_dialog_params *)GetWindowLongPtrW(hwndDlg, DWLP_USER);
499                         CredDialogShowCapsLockBalloon(hwndDlg, params);
500                     }
501                     /* don't allow another window to steal focus while the
502                      * user is typing their password */
503                     LockSetForegroundWindow(LSFW_LOCK);
504                     return TRUE;
505                 case MAKELONG(IDC_PASSWORD, EN_KILLFOCUS):
506                 {
507                     struct cred_dialog_params *params =
508                         (struct cred_dialog_params *)GetWindowLongPtrW(hwndDlg, DWLP_USER);
509                     /* the user is no longer typing their password, so allow
510                      * other windows to become foreground ones */
511                     LockSetForegroundWindow(LSFW_UNLOCK);
512                     CredDialogHideBalloonTip(hwndDlg, params);
513                     return TRUE;
514                 }
515                 case MAKELONG(IDC_PASSWORD, EN_CHANGE):
516                 {
517                     struct cred_dialog_params *params =
518                         (struct cred_dialog_params *)GetWindowLongPtrW(hwndDlg, DWLP_USER);
519                     CredDialogHideBalloonTip(hwndDlg, params);
520                     return TRUE;
521                 }
522             }
523             return FALSE;
524         case WM_TIMER:
525             if (wParam == ID_CAPSLOCKPOP)
526             {
527                 struct cred_dialog_params *params =
528                     (struct cred_dialog_params *)GetWindowLongPtrW(hwndDlg, DWLP_USER);
529                 CredDialogHideBalloonTip(hwndDlg, params);
530                 return TRUE;
531             }
532             return FALSE;
533         case WM_DESTROY:
534         {
535             struct cred_dialog_params *params =
536                 (struct cred_dialog_params *)GetWindowLongPtrW(hwndDlg, DWLP_USER);
537             if (params->hwndBalloonTip) DestroyWindow(params->hwndBalloonTip);
538             return TRUE;
539         }
540         default:
541             return FALSE;
542     }
543 }
544
545 /******************************************************************************
546  *           CredUIPromptForCredentialsW [CREDUI.@]
547  */
548 DWORD WINAPI CredUIPromptForCredentialsW(PCREDUI_INFOW pUIInfo,
549                                          PCWSTR pszTargetName,
550                                          PCtxtHandle Reserved,
551                                          DWORD dwAuthError,
552                                          PWSTR pszUsername,
553                                          ULONG ulUsernameMaxChars,
554                                          PWSTR pszPassword,
555                                          ULONG ulPasswordMaxChars, PBOOL pfSave,
556                                          DWORD dwFlags)
557 {
558     INT_PTR ret;
559     struct cred_dialog_params params;
560     DWORD result = ERROR_SUCCESS;
561
562     TRACE("(%p, %s, %p, %d, %s, %d, %p, %d, %p, 0x%08x)\n", pUIInfo,
563           debugstr_w(pszTargetName), Reserved, dwAuthError, debugstr_w(pszUsername),
564           ulUsernameMaxChars, pszPassword, ulPasswordMaxChars, pfSave, dwFlags);
565
566     if ((dwFlags & (CREDUI_FLAGS_ALWAYS_SHOW_UI|CREDUI_FLAGS_GENERIC_CREDENTIALS)) == CREDUI_FLAGS_ALWAYS_SHOW_UI)
567         return ERROR_INVALID_FLAGS;
568
569     if (!pszTargetName)
570         return ERROR_INVALID_PARAMETER;
571
572     if ((dwFlags & CREDUI_FLAGS_SHOW_SAVE_CHECK_BOX) && !pfSave)
573         return ERROR_INVALID_PARAMETER;
574
575     params.pszTargetName = pszTargetName;
576     if (pUIInfo)
577     {
578         params.pszMessageText = pUIInfo->pszMessageText;
579         params.pszCaptionText = pUIInfo->pszCaptionText;
580         params.hbmBanner  = pUIInfo->hbmBanner;
581     }
582     else
583     {
584         params.pszMessageText = NULL;
585         params.pszCaptionText = NULL;
586         params.hbmBanner = NULL;
587     }
588     params.pszUsername = pszUsername;
589     params.ulUsernameMaxChars = ulUsernameMaxChars;
590     params.pszPassword = pszPassword;
591     params.ulPasswordMaxChars = ulPasswordMaxChars;
592     params.fSave = pfSave ? *pfSave : FALSE;
593     params.dwFlags = dwFlags;
594     params.hwndBalloonTip = NULL;
595     params.fBalloonTipActive = FALSE;
596
597     ret = DialogBoxParamW(hinstCredUI, MAKEINTRESOURCEW(IDD_CREDDIALOG),
598                           pUIInfo ? pUIInfo->hwndParent : NULL,
599                           CredDialogProc, (LPARAM)&params);
600     if (ret <= 0)
601         return GetLastError();
602
603     if (ret == IDCANCEL)
604     {
605         TRACE("dialog cancelled\n");
606         return ERROR_CANCELLED;
607     }
608
609     if (pfSave)
610         *pfSave = params.fSave;
611
612     if (params.fSave)
613     {
614         if (dwFlags & CREDUI_FLAGS_EXPECT_CONFIRMATION)
615         {
616             BOOL found = FALSE;
617             struct pending_credentials *entry;
618             int len;
619
620             EnterCriticalSection(&csPendingCredentials);
621
622             /* find existing pending credentials for the same target and overwrite */
623             /* FIXME: is this correct? */
624             LIST_FOR_EACH_ENTRY(entry, &pending_credentials_list, struct pending_credentials, entry)
625                 if (!strcmpW(pszTargetName, entry->pszTargetName))
626                 {
627                     found = TRUE;
628                     HeapFree(GetProcessHeap(), 0, entry->pszUsername);
629                     ZeroMemory(entry->pszPassword, (strlenW(entry->pszPassword) + 1) * sizeof(WCHAR));
630                     HeapFree(GetProcessHeap(), 0, entry->pszPassword);
631                 }
632
633             if (!found)
634             {
635                 entry = HeapAlloc(GetProcessHeap(), 0, sizeof(*entry));
636                 len = strlenW(pszTargetName);
637                 entry->pszTargetName = HeapAlloc(GetProcessHeap(), 0, (len + 1)*sizeof(WCHAR));
638                 memcpy(entry->pszTargetName, pszTargetName, (len + 1)*sizeof(WCHAR));
639                 list_add_tail(&pending_credentials_list, &entry->entry);
640             }
641
642             len = strlenW(params.pszUsername);
643             entry->pszUsername = HeapAlloc(GetProcessHeap(), 0, (len + 1)*sizeof(WCHAR));
644             memcpy(entry->pszUsername, params.pszUsername, (len + 1)*sizeof(WCHAR));
645             len = strlenW(params.pszPassword);
646             entry->pszPassword = HeapAlloc(GetProcessHeap(), 0, (len + 1)*sizeof(WCHAR));
647             memcpy(entry->pszPassword, params.pszPassword, (len + 1)*sizeof(WCHAR));
648             entry->generic = dwFlags & CREDUI_FLAGS_GENERIC_CREDENTIALS ? TRUE : FALSE;
649
650             LeaveCriticalSection(&csPendingCredentials);
651         }
652         else
653             result = save_credentials(pszTargetName, pszUsername, pszPassword,
654                                       dwFlags & CREDUI_FLAGS_GENERIC_CREDENTIALS ? TRUE : FALSE);
655     }
656
657     return result;
658 }
659
660 /******************************************************************************
661  *           CredUIConfirmCredentialsW [CREDUI.@]
662  */
663 DWORD WINAPI CredUIConfirmCredentialsW(PCWSTR pszTargetName, BOOL bConfirm)
664 {
665     struct pending_credentials *entry;
666     DWORD result = ERROR_NOT_FOUND;
667
668     TRACE("(%s, %s)\n", debugstr_w(pszTargetName), bConfirm ? "TRUE" : "FALSE");
669
670     if (!pszTargetName)
671         return ERROR_INVALID_PARAMETER;
672
673     EnterCriticalSection(&csPendingCredentials);
674
675     LIST_FOR_EACH_ENTRY(entry, &pending_credentials_list, struct pending_credentials, entry)
676     {
677         if (!strcmpW(pszTargetName, entry->pszTargetName))
678         {
679             if (bConfirm)
680                 result = save_credentials(entry->pszTargetName, entry->pszUsername,
681                                           entry->pszPassword, entry->generic);
682             else
683                 result = ERROR_SUCCESS;
684
685             list_remove(&entry->entry);
686
687             HeapFree(GetProcessHeap(), 0, entry->pszTargetName);
688             HeapFree(GetProcessHeap(), 0, entry->pszUsername);
689             ZeroMemory(entry->pszPassword, (strlenW(entry->pszPassword) + 1) * sizeof(WCHAR));
690             HeapFree(GetProcessHeap(), 0, entry->pszPassword);
691             HeapFree(GetProcessHeap(), 0, entry);
692
693             break;
694         }
695     }
696
697     LeaveCriticalSection(&csPendingCredentials);
698
699     return result;
700 }
701
702 /******************************************************************************
703  *           CredUIParseUserNameW [CREDUI.@]
704  */
705 DWORD WINAPI CredUIParseUserNameW(PCWSTR pszUserName, PWSTR pszUser,
706                                   ULONG ulMaxUserChars, PWSTR pszDomain,
707                                   ULONG ulMaxDomainChars)
708 {
709     PWSTR p;
710
711     TRACE("(%s, %p, %d, %p, %d)\n", debugstr_w(pszUserName), pszUser,
712           ulMaxUserChars, pszDomain, ulMaxDomainChars);
713
714     if (!pszUserName || !pszUser || !ulMaxUserChars || !pszDomain ||
715         !ulMaxDomainChars)
716         return ERROR_INVALID_PARAMETER;
717
718     /* FIXME: handle marshaled credentials */
719
720     p = strchrW(pszUserName, '\\');
721     if (p)
722     {
723         if (p - pszUserName > ulMaxDomainChars - 1)
724             return ERROR_INSUFFICIENT_BUFFER;
725         if (strlenW(p + 1) > ulMaxUserChars - 1)
726             return ERROR_INSUFFICIENT_BUFFER;
727         strcpyW(pszUser, p + 1);
728         memcpy(pszDomain, pszUserName, (p - pszUserName)*sizeof(WCHAR));
729         pszDomain[p - pszUserName] = '\0';
730
731         return ERROR_SUCCESS;
732     }
733
734     p = strrchrW(pszUserName, '@');
735     if (p)
736     {
737         if (p + 1 - pszUserName > ulMaxUserChars - 1)
738             return ERROR_INSUFFICIENT_BUFFER;
739         if (strlenW(p + 1) > ulMaxDomainChars - 1)
740             return ERROR_INSUFFICIENT_BUFFER;
741         strcpyW(pszDomain, p + 1);
742         memcpy(pszUser, pszUserName, (p - pszUserName)*sizeof(WCHAR));
743         pszUser[p - pszUserName] = '\0';
744
745         return ERROR_SUCCESS;
746     }
747
748     if (strlenW(pszUserName) > ulMaxUserChars - 1)
749         return ERROR_INSUFFICIENT_BUFFER;
750     strcpyW(pszUser, pszUserName);
751     pszDomain[0] = '\0';
752
753     return ERROR_SUCCESS;
754 }
755
756 /******************************************************************************
757  *           CredUIStoreSSOCredA [CREDUI.@]
758  */
759 DWORD WINAPI CredUIStoreSSOCredA(PCSTR pszRealm, PCSTR pszUsername,
760                                  PCSTR pszPassword, BOOL bPersist)
761 {
762     FIXME("(%s, %s, %p, %d)\n", debugstr_a(pszRealm), debugstr_a(pszUsername),
763           pszPassword, bPersist);
764     return ERROR_SUCCESS;
765 }
766
767 /******************************************************************************
768  *           CredUIStoreSSOCredW [CREDUI.@]
769  */
770 DWORD WINAPI CredUIStoreSSOCredW(PCWSTR pszRealm, PCWSTR pszUsername,
771                                  PCWSTR pszPassword, BOOL bPersist)
772 {
773     FIXME("(%s, %s, %p, %d)\n", debugstr_w(pszRealm), debugstr_w(pszUsername),
774           pszPassword, bPersist);
775     return ERROR_SUCCESS;
776 }
777
778 /******************************************************************************
779  *           CredUIReadSSOCredA [CREDUI.@]
780  */
781 DWORD WINAPI CredUIReadSSOCredA(PCSTR pszRealm, PSTR *ppszUsername)
782 {
783     FIXME("(%s, %p)\n", debugstr_a(pszRealm), ppszUsername);
784     if (ppszUsername)
785         *ppszUsername = NULL;
786     return ERROR_NOT_FOUND;
787 }
788
789 /******************************************************************************
790  *           CredUIReadSSOCredW [CREDUI.@]
791  */
792 DWORD WINAPI CredUIReadSSOCredW(PCWSTR pszRealm, PWSTR *ppszUsername)
793 {
794     FIXME("(%s, %p)\n", debugstr_w(pszRealm), ppszUsername);
795     if (ppszUsername)
796         *ppszUsername = NULL;
797     return ERROR_NOT_FOUND;
798 }