[CREDUI] Sync with Wine Staging 1.7.55. CORE-10536
[reactos.git] / reactos / dll / win32 / 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 #define WIN32_NO_STATUS
22
23 #include <stdarg.h>
24
25 #include <windef.h>
26 #include <winbase.h>
27 //#include "winnt.h"
28 #include <winuser.h>
29 #include <wincred.h>
30 #include <sspi.h>
31 #include <commctrl.h>
32
33 #include "credui_resources.h"
34
35 #include <wine/debug.h>
36 #include <wine/unicode.h>
37 #include <wine/list.h>
38
39 WINE_DEFAULT_DEBUG_CHANNEL(credui);
40
41 #define TOOLID_INCORRECTPASSWORD 1
42 #define TOOLID_CAPSLOCKON 2
43
44 #define ID_CAPSLOCKPOP 1
45
46 struct pending_credentials
47 {
48 struct list entry;
49 PWSTR pszTargetName;
50 PWSTR pszUsername;
51 PWSTR pszPassword;
52 BOOL generic;
53 };
54
55 static HINSTANCE hinstCredUI;
56
57 static struct list pending_credentials_list = LIST_INIT(pending_credentials_list);
58
59 static CRITICAL_SECTION csPendingCredentials;
60 static CRITICAL_SECTION_DEBUG critsect_debug =
61 {
62 0, 0, &csPendingCredentials,
63 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
64 0, 0, { (DWORD_PTR)(__FILE__ ": csPendingCredentials") }
65 };
66 static CRITICAL_SECTION csPendingCredentials = { &critsect_debug, -1, 0, 0, 0, 0 };
67
68
69 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
70 {
71 struct pending_credentials *entry, *cursor2;
72 TRACE("(0x%p, %d, %p)\n",hinstDLL,fdwReason,lpvReserved);
73
74 switch (fdwReason)
75 {
76 case DLL_WINE_PREATTACH:
77 return FALSE; /* prefer native version */
78
79 case DLL_PROCESS_ATTACH:
80 DisableThreadLibraryCalls(hinstDLL);
81 hinstCredUI = hinstDLL;
82 InitCommonControls();
83 break;
84
85 case DLL_PROCESS_DETACH:
86 if (lpvReserved) break;
87 LIST_FOR_EACH_ENTRY_SAFE(entry, cursor2, &pending_credentials_list, struct pending_credentials, entry)
88 {
89 list_remove(&entry->entry);
90
91 HeapFree(GetProcessHeap(), 0, entry->pszTargetName);
92 HeapFree(GetProcessHeap(), 0, entry->pszUsername);
93 ZeroMemory(entry->pszPassword, (strlenW(entry->pszPassword) + 1) * sizeof(WCHAR));
94 HeapFree(GetProcessHeap(), 0, entry->pszPassword);
95 HeapFree(GetProcessHeap(), 0, entry);
96 }
97 DeleteCriticalSection(&csPendingCredentials);
98 break;
99 }
100
101 return TRUE;
102 }
103
104 static DWORD save_credentials(PCWSTR pszTargetName, PCWSTR pszUsername,
105 PCWSTR pszPassword, BOOL generic)
106 {
107 CREDENTIALW cred;
108
109 TRACE("saving servername %s with username %s\n", debugstr_w(pszTargetName), debugstr_w(pszUsername));
110
111 cred.Flags = 0;
112 cred.Type = generic ? CRED_TYPE_GENERIC : CRED_TYPE_DOMAIN_PASSWORD;
113 cred.TargetName = (LPWSTR)pszTargetName;
114 cred.Comment = NULL;
115 cred.CredentialBlobSize = strlenW(pszPassword) * sizeof(WCHAR);
116 cred.CredentialBlob = (LPBYTE)pszPassword;
117 cred.Persist = CRED_PERSIST_ENTERPRISE;
118 cred.AttributeCount = 0;
119 cred.Attributes = NULL;
120 cred.TargetAlias = NULL;
121 cred.UserName = (LPWSTR)pszUsername;
122
123 if (CredWriteW(&cred, 0))
124 return ERROR_SUCCESS;
125 else
126 {
127 DWORD ret = GetLastError();
128 ERR("CredWriteW failed with error %d\n", ret);
129 return ret;
130 }
131 }
132
133 struct cred_dialog_params
134 {
135 PCWSTR pszTargetName;
136 PCWSTR pszMessageText;
137 PCWSTR pszCaptionText;
138 HBITMAP hbmBanner;
139 PWSTR pszUsername;
140 ULONG ulUsernameMaxChars;
141 PWSTR pszPassword;
142 ULONG ulPasswordMaxChars;
143 BOOL fSave;
144 DWORD dwFlags;
145 HWND hwndBalloonTip;
146 BOOL fBalloonTipActive;
147 };
148
149 static void CredDialogFillUsernameCombo(HWND hwndUsername, const struct cred_dialog_params *params)
150 {
151 DWORD count;
152 DWORD i;
153 PCREDENTIALW *credentials;
154
155 if (!CredEnumerateW(NULL, 0, &count, &credentials))
156 return;
157
158 for (i = 0; i < count; i++)
159 {
160 COMBOBOXEXITEMW comboitem;
161 DWORD j;
162 BOOL duplicate = FALSE;
163
164 if (params->dwFlags & CREDUI_FLAGS_GENERIC_CREDENTIALS)
165 {
166 if ((credentials[i]->Type != CRED_TYPE_GENERIC) || !credentials[i]->UserName)
167 continue;
168 }
169 else
170 {
171 if (credentials[i]->Type == CRED_TYPE_GENERIC)
172 continue;
173 }
174
175 /* don't add another item with the same name if we've already added it */
176 for (j = 0; j < i; j++)
177 if (!strcmpW(credentials[i]->UserName, credentials[j]->UserName))
178 {
179 duplicate = TRUE;
180 break;
181 }
182
183 if (duplicate)
184 continue;
185
186 comboitem.mask = CBEIF_TEXT;
187 comboitem.iItem = -1;
188 comboitem.pszText = credentials[i]->UserName;
189 SendMessageW(hwndUsername, CBEM_INSERTITEMW, 0, (LPARAM)&comboitem);
190 }
191
192 CredFree(credentials);
193 }
194
195 static void CredDialogCreateBalloonTip(HWND hwndDlg, struct cred_dialog_params *params)
196 {
197 TTTOOLINFOW toolinfo;
198 WCHAR wszText[256];
199
200 if (params->hwndBalloonTip)
201 return;
202
203 params->hwndBalloonTip = CreateWindowExW(WS_EX_TOOLWINDOW, TOOLTIPS_CLASSW,
204 NULL, WS_POPUP | TTS_NOPREFIX | TTS_BALLOON, CW_USEDEFAULT,
205 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, hwndDlg, NULL,
206 hinstCredUI, NULL);
207 SetWindowPos(params->hwndBalloonTip, HWND_TOPMOST, 0, 0, 0, 0,
208 SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
209
210 if (!LoadStringW(hinstCredUI, IDS_INCORRECTPASSWORD, wszText, sizeof(wszText)/sizeof(wszText[0])))
211 {
212 ERR("failed to load IDS_INCORRECTPASSWORD\n");
213 return;
214 }
215
216 toolinfo.cbSize = sizeof(toolinfo);
217 toolinfo.uFlags = TTF_TRACK;
218 toolinfo.hwnd = hwndDlg;
219 toolinfo.uId = TOOLID_INCORRECTPASSWORD;
220 memset(&toolinfo.rect, 0, sizeof(toolinfo.rect));
221 toolinfo.hinst = NULL;
222 toolinfo.lpszText = wszText;
223 toolinfo.lParam = 0;
224 toolinfo.lpReserved = NULL;
225 SendMessageW(params->hwndBalloonTip, TTM_ADDTOOLW, 0, (LPARAM)&toolinfo);
226
227 if (!LoadStringW(hinstCredUI, IDS_CAPSLOCKON, wszText, sizeof(wszText)/sizeof(wszText[0])))
228 {
229 ERR("failed to load IDS_CAPSLOCKON\n");
230 return;
231 }
232
233 toolinfo.uId = TOOLID_CAPSLOCKON;
234 SendMessageW(params->hwndBalloonTip, TTM_ADDTOOLW, 0, (LPARAM)&toolinfo);
235 }
236
237 static void CredDialogShowIncorrectPasswordBalloon(HWND hwndDlg, struct cred_dialog_params *params)
238 {
239 TTTOOLINFOW toolinfo;
240 RECT rcPassword;
241 INT x;
242 INT y;
243 WCHAR wszTitle[256];
244
245 /* user name likely wrong so balloon would be confusing. focus is also
246 * not set to the password edit box, so more notification would need to be
247 * handled */
248 if (!params->pszUsername[0])
249 return;
250
251 /* don't show two balloon tips at once */
252 if (params->fBalloonTipActive)
253 return;
254
255 if (!LoadStringW(hinstCredUI, IDS_INCORRECTPASSWORDTITLE, wszTitle, sizeof(wszTitle)/sizeof(wszTitle[0])))
256 {
257 ERR("failed to load IDS_INCORRECTPASSWORDTITLE\n");
258 return;
259 }
260
261 CredDialogCreateBalloonTip(hwndDlg, params);
262
263 memset(&toolinfo, 0, sizeof(toolinfo));
264 toolinfo.cbSize = sizeof(toolinfo);
265 toolinfo.hwnd = hwndDlg;
266 toolinfo.uId = TOOLID_INCORRECTPASSWORD;
267
268 SendMessageW(params->hwndBalloonTip, TTM_SETTITLEW, TTI_ERROR, (LPARAM)wszTitle);
269
270 GetWindowRect(GetDlgItem(hwndDlg, IDC_PASSWORD), &rcPassword);
271 /* centered vertically and in the right side of the password edit control */
272 x = rcPassword.right - 12;
273 y = (rcPassword.top + rcPassword.bottom) / 2;
274 SendMessageW(params->hwndBalloonTip, TTM_TRACKPOSITION, 0, MAKELONG(x, y));
275
276 SendMessageW(params->hwndBalloonTip, TTM_TRACKACTIVATE, TRUE, (LPARAM)&toolinfo);
277
278 params->fBalloonTipActive = TRUE;
279 }
280
281 static void CredDialogShowCapsLockBalloon(HWND hwndDlg, struct cred_dialog_params *params)
282 {
283 TTTOOLINFOW toolinfo;
284 RECT rcPassword;
285 INT x;
286 INT y;
287 WCHAR wszTitle[256];
288
289 /* don't show two balloon tips at once */
290 if (params->fBalloonTipActive)
291 return;
292
293 if (!LoadStringW(hinstCredUI, IDS_CAPSLOCKONTITLE, wszTitle, sizeof(wszTitle)/sizeof(wszTitle[0])))
294 {
295 ERR("failed to load IDS_IDSCAPSLOCKONTITLE\n");
296 return;
297 }
298
299 CredDialogCreateBalloonTip(hwndDlg, params);
300
301 memset(&toolinfo, 0, sizeof(toolinfo));
302 toolinfo.cbSize = sizeof(toolinfo);
303 toolinfo.hwnd = hwndDlg;
304 toolinfo.uId = TOOLID_CAPSLOCKON;
305
306 SendMessageW(params->hwndBalloonTip, TTM_SETTITLEW, TTI_WARNING, (LPARAM)wszTitle);
307
308 GetWindowRect(GetDlgItem(hwndDlg, IDC_PASSWORD), &rcPassword);
309 /* just inside the left side of the password edit control */
310 x = rcPassword.left + 12;
311 y = rcPassword.bottom - 3;
312 SendMessageW(params->hwndBalloonTip, TTM_TRACKPOSITION, 0, MAKELONG(x, y));
313
314 SendMessageW(params->hwndBalloonTip, TTM_TRACKACTIVATE, TRUE, (LPARAM)&toolinfo);
315
316 SetTimer(hwndDlg, ID_CAPSLOCKPOP,
317 SendMessageW(params->hwndBalloonTip, TTM_GETDELAYTIME, TTDT_AUTOPOP, 0),
318 NULL);
319
320 params->fBalloonTipActive = TRUE;
321 }
322
323 static void CredDialogHideBalloonTip(HWND hwndDlg, struct cred_dialog_params *params)
324 {
325 TTTOOLINFOW toolinfo;
326
327 if (!params->hwndBalloonTip)
328 return;
329
330 memset(&toolinfo, 0, sizeof(toolinfo));
331
332 toolinfo.cbSize = sizeof(toolinfo);
333 toolinfo.hwnd = hwndDlg;
334 toolinfo.uId = 0;
335 SendMessageW(params->hwndBalloonTip, TTM_TRACKACTIVATE, FALSE, (LPARAM)&toolinfo);
336 toolinfo.uId = 1;
337 SendMessageW(params->hwndBalloonTip, TTM_TRACKACTIVATE, FALSE, (LPARAM)&toolinfo);
338
339 params->fBalloonTipActive = FALSE;
340 }
341
342 static inline BOOL CredDialogCapsLockOn(void)
343 {
344 return (GetKeyState(VK_CAPITAL) & 0x1) != 0;
345 }
346
347 static LRESULT CALLBACK CredDialogPasswordSubclassProc(HWND hwnd, UINT uMsg,
348 WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
349 {
350 struct cred_dialog_params *params = (struct cred_dialog_params *)dwRefData;
351 switch (uMsg)
352 {
353 case WM_KEYDOWN:
354 if (wParam == VK_CAPITAL)
355 {
356 HWND hwndDlg = GetParent(hwnd);
357 if (CredDialogCapsLockOn())
358 CredDialogShowCapsLockBalloon(hwndDlg, params);
359 else
360 CredDialogHideBalloonTip(hwndDlg, params);
361 }
362 break;
363 case WM_DESTROY:
364 RemoveWindowSubclass(hwnd, CredDialogPasswordSubclassProc, uIdSubclass);
365 break;
366 }
367 return DefSubclassProc(hwnd, uMsg, wParam, lParam);
368 }
369
370 static BOOL CredDialogInit(HWND hwndDlg, struct cred_dialog_params *params)
371 {
372 HWND hwndUsername = GetDlgItem(hwndDlg, IDC_USERNAME);
373 HWND hwndPassword = GetDlgItem(hwndDlg, IDC_PASSWORD);
374
375 SetWindowLongPtrW(hwndDlg, DWLP_USER, (LONG_PTR)params);
376
377 if (params->hbmBanner)
378 SendMessageW(GetDlgItem(hwndDlg, IDB_BANNER), STM_SETIMAGE,
379 IMAGE_BITMAP, (LPARAM)params->hbmBanner);
380
381 if (params->pszMessageText)
382 SetDlgItemTextW(hwndDlg, IDC_MESSAGE, params->pszMessageText);
383 else
384 {
385 WCHAR format[256];
386 WCHAR message[256];
387 LoadStringW(hinstCredUI, IDS_MESSAGEFORMAT, format, sizeof(format)/sizeof(format[0]));
388 snprintfW(message, sizeof(message)/sizeof(message[0]), format, params->pszTargetName);
389 SetDlgItemTextW(hwndDlg, IDC_MESSAGE, message);
390 }
391 SetWindowTextW(hwndUsername, params->pszUsername);
392 SetWindowTextW(hwndPassword, params->pszPassword);
393
394 CredDialogFillUsernameCombo(hwndUsername, params);
395
396 if (params->pszUsername[0])
397 {
398 /* prevent showing a balloon tip here */
399 params->fBalloonTipActive = TRUE;
400 SetFocus(hwndPassword);
401 params->fBalloonTipActive = FALSE;
402 }
403 else
404 SetFocus(hwndUsername);
405
406 if (params->pszCaptionText)
407 SetWindowTextW(hwndDlg, params->pszCaptionText);
408 else
409 {
410 WCHAR format[256];
411 WCHAR title[256];
412 LoadStringW(hinstCredUI, IDS_TITLEFORMAT, format, sizeof(format)/sizeof(format[0]));
413 snprintfW(title, sizeof(title)/sizeof(title[0]), format, params->pszTargetName);
414 SetWindowTextW(hwndDlg, title);
415 }
416
417 if (params->dwFlags & CREDUI_FLAGS_PERSIST ||
418 (params->dwFlags & CREDUI_FLAGS_DO_NOT_PERSIST &&
419 !(params->dwFlags & CREDUI_FLAGS_SHOW_SAVE_CHECK_BOX)))
420 ShowWindow(GetDlgItem(hwndDlg, IDC_SAVE), SW_HIDE);
421 else if (params->fSave)
422 CheckDlgButton(hwndDlg, IDC_SAVE, BST_CHECKED);
423
424 /* setup subclassing for Caps Lock detection */
425 SetWindowSubclass(hwndPassword, CredDialogPasswordSubclassProc, 1, (DWORD_PTR)params);
426
427 if (params->dwFlags & CREDUI_FLAGS_INCORRECT_PASSWORD)
428 CredDialogShowIncorrectPasswordBalloon(hwndDlg, params);
429 else if ((GetFocus() == hwndPassword) && CredDialogCapsLockOn())
430 CredDialogShowCapsLockBalloon(hwndDlg, params);
431
432 return FALSE;
433 }
434
435 static void CredDialogCommandOk(HWND hwndDlg, struct cred_dialog_params *params)
436 {
437 HWND hwndUsername = GetDlgItem(hwndDlg, IDC_USERNAME);
438 LPWSTR user;
439 INT len;
440 INT len2;
441
442 len = GetWindowTextLengthW(hwndUsername);
443 user = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
444 GetWindowTextW(hwndUsername, user, len + 1);
445
446 if (!user[0])
447 {
448 HeapFree(GetProcessHeap(), 0, user);
449 return;
450 }
451
452 if (!strchrW(user, '\\') && !strchrW(user, '@'))
453 {
454 ULONG len_target = strlenW(params->pszTargetName);
455 memcpy(params->pszUsername, params->pszTargetName,
456 min(len_target, params->ulUsernameMaxChars) * sizeof(WCHAR));
457 if (len_target + 1 < params->ulUsernameMaxChars)
458 params->pszUsername[len_target] = '\\';
459 if (len_target + 2 < params->ulUsernameMaxChars)
460 params->pszUsername[len_target + 1] = '\0';
461 }
462 else if (params->ulUsernameMaxChars > 0)
463 params->pszUsername[0] = '\0';
464
465 len2 = strlenW(params->pszUsername);
466 memcpy(params->pszUsername + len2, user, min(len, params->ulUsernameMaxChars - len2) * sizeof(WCHAR));
467 if (params->ulUsernameMaxChars)
468 params->pszUsername[len2 + min(len, params->ulUsernameMaxChars - len2 - 1)] = '\0';
469
470 HeapFree(GetProcessHeap(), 0, user);
471
472 GetDlgItemTextW(hwndDlg, IDC_PASSWORD, params->pszPassword,
473 params->ulPasswordMaxChars);
474
475 params->fSave = IsDlgButtonChecked(hwndDlg, IDC_SAVE) == BST_CHECKED;
476
477 EndDialog(hwndDlg, IDOK);
478 }
479
480 static INT_PTR CALLBACK CredDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,
481 LPARAM lParam)
482 {
483 switch (uMsg)
484 {
485 case WM_INITDIALOG:
486 {
487 struct cred_dialog_params *params = (struct cred_dialog_params *)lParam;
488
489 return CredDialogInit(hwndDlg, params);
490 }
491 case WM_COMMAND:
492 switch (wParam)
493 {
494 case MAKELONG(IDOK, BN_CLICKED):
495 {
496 struct cred_dialog_params *params =
497 (struct cred_dialog_params *)GetWindowLongPtrW(hwndDlg, DWLP_USER);
498 CredDialogCommandOk(hwndDlg, params);
499 return TRUE;
500 }
501 case MAKELONG(IDCANCEL, BN_CLICKED):
502 EndDialog(hwndDlg, IDCANCEL);
503 return TRUE;
504 case MAKELONG(IDC_PASSWORD, EN_SETFOCUS):
505 if (CredDialogCapsLockOn())
506 {
507 struct cred_dialog_params *params =
508 (struct cred_dialog_params *)GetWindowLongPtrW(hwndDlg, DWLP_USER);
509 CredDialogShowCapsLockBalloon(hwndDlg, params);
510 }
511 /* don't allow another window to steal focus while the
512 * user is typing their password */
513 LockSetForegroundWindow(LSFW_LOCK);
514 return TRUE;
515 case MAKELONG(IDC_PASSWORD, EN_KILLFOCUS):
516 {
517 struct cred_dialog_params *params =
518 (struct cred_dialog_params *)GetWindowLongPtrW(hwndDlg, DWLP_USER);
519 /* the user is no longer typing their password, so allow
520 * other windows to become foreground ones */
521 LockSetForegroundWindow(LSFW_UNLOCK);
522 CredDialogHideBalloonTip(hwndDlg, params);
523 return TRUE;
524 }
525 case MAKELONG(IDC_PASSWORD, EN_CHANGE):
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 }
533 return FALSE;
534 case WM_TIMER:
535 if (wParam == ID_CAPSLOCKPOP)
536 {
537 struct cred_dialog_params *params =
538 (struct cred_dialog_params *)GetWindowLongPtrW(hwndDlg, DWLP_USER);
539 CredDialogHideBalloonTip(hwndDlg, params);
540 return TRUE;
541 }
542 return FALSE;
543 case WM_DESTROY:
544 {
545 struct cred_dialog_params *params =
546 (struct cred_dialog_params *)GetWindowLongPtrW(hwndDlg, DWLP_USER);
547 if (params->hwndBalloonTip) DestroyWindow(params->hwndBalloonTip);
548 return TRUE;
549 }
550 default:
551 return FALSE;
552 }
553 }
554
555 static BOOL find_existing_credential(const WCHAR *target, WCHAR *username, ULONG len_username,
556 WCHAR *password, ULONG len_password)
557 {
558 DWORD count, i;
559 CREDENTIALW **credentials;
560
561 if (!CredEnumerateW(target, 0, &count, &credentials)) return FALSE;
562 for (i = 0; i < count; i++)
563 {
564 if (credentials[i]->Type != CRED_TYPE_DOMAIN_PASSWORD &&
565 credentials[i]->Type != CRED_TYPE_GENERIC)
566 {
567 FIXME("no support for type %u credentials\n", credentials[i]->Type);
568 continue;
569 }
570 if ((!*username || !strcmpW(username, credentials[i]->UserName)) &&
571 strlenW(credentials[i]->UserName) < len_username &&
572 credentials[i]->CredentialBlobSize / sizeof(WCHAR) < len_password)
573 {
574 TRACE("found existing credential for %s\n", debugstr_w(credentials[i]->UserName));
575
576 strcpyW(username, credentials[i]->UserName);
577 memcpy(password, credentials[i]->CredentialBlob, credentials[i]->CredentialBlobSize);
578 password[credentials[i]->CredentialBlobSize / sizeof(WCHAR)] = 0;
579
580 CredFree(credentials);
581 return TRUE;
582 }
583 }
584 CredFree(credentials);
585 return FALSE;
586 }
587
588 /******************************************************************************
589 * CredUIPromptForCredentialsW [CREDUI.@]
590 */
591 DWORD WINAPI CredUIPromptForCredentialsW(PCREDUI_INFOW pUIInfo,
592 PCWSTR pszTargetName,
593 PCtxtHandle Reserved,
594 DWORD dwAuthError,
595 PWSTR pszUsername,
596 ULONG ulUsernameMaxChars,
597 PWSTR pszPassword,
598 ULONG ulPasswordMaxChars, PBOOL pfSave,
599 DWORD dwFlags)
600 {
601 INT_PTR ret;
602 struct cred_dialog_params params;
603 DWORD result = ERROR_SUCCESS;
604
605 TRACE("(%p, %s, %p, %d, %s, %d, %p, %d, %p, 0x%08x)\n", pUIInfo,
606 debugstr_w(pszTargetName), Reserved, dwAuthError, debugstr_w(pszUsername),
607 ulUsernameMaxChars, pszPassword, ulPasswordMaxChars, pfSave, dwFlags);
608
609 if ((dwFlags & (CREDUI_FLAGS_ALWAYS_SHOW_UI|CREDUI_FLAGS_GENERIC_CREDENTIALS)) == CREDUI_FLAGS_ALWAYS_SHOW_UI)
610 return ERROR_INVALID_FLAGS;
611
612 if (!pszTargetName)
613 return ERROR_INVALID_PARAMETER;
614
615 if ((dwFlags & CREDUI_FLAGS_SHOW_SAVE_CHECK_BOX) && !pfSave)
616 return ERROR_INVALID_PARAMETER;
617
618 if (!(dwFlags & CREDUI_FLAGS_ALWAYS_SHOW_UI) &&
619 !(dwFlags & CREDUI_FLAGS_INCORRECT_PASSWORD) &&
620 find_existing_credential(pszTargetName, pszUsername, ulUsernameMaxChars, pszPassword, ulPasswordMaxChars))
621 return ERROR_SUCCESS;
622
623 params.pszTargetName = pszTargetName;
624 if (pUIInfo)
625 {
626 params.pszMessageText = pUIInfo->pszMessageText;
627 params.pszCaptionText = pUIInfo->pszCaptionText;
628 params.hbmBanner = pUIInfo->hbmBanner;
629 }
630 else
631 {
632 params.pszMessageText = NULL;
633 params.pszCaptionText = NULL;
634 params.hbmBanner = NULL;
635 }
636 params.pszUsername = pszUsername;
637 params.ulUsernameMaxChars = ulUsernameMaxChars;
638 params.pszPassword = pszPassword;
639 params.ulPasswordMaxChars = ulPasswordMaxChars;
640 params.fSave = pfSave ? *pfSave : FALSE;
641 params.dwFlags = dwFlags;
642 params.hwndBalloonTip = NULL;
643 params.fBalloonTipActive = FALSE;
644
645 ret = DialogBoxParamW(hinstCredUI, MAKEINTRESOURCEW(IDD_CREDDIALOG),
646 pUIInfo ? pUIInfo->hwndParent : NULL,
647 CredDialogProc, (LPARAM)&params);
648 if (ret <= 0)
649 return GetLastError();
650
651 if (ret == IDCANCEL)
652 {
653 TRACE("dialog cancelled\n");
654 return ERROR_CANCELLED;
655 }
656
657 if (pfSave)
658 *pfSave = params.fSave;
659
660 if (params.fSave)
661 {
662 if (dwFlags & CREDUI_FLAGS_EXPECT_CONFIRMATION)
663 {
664 BOOL found = FALSE;
665 struct pending_credentials *entry;
666 int len;
667
668 EnterCriticalSection(&csPendingCredentials);
669
670 /* find existing pending credentials for the same target and overwrite */
671 /* FIXME: is this correct? */
672 LIST_FOR_EACH_ENTRY(entry, &pending_credentials_list, struct pending_credentials, entry)
673 if (!strcmpW(pszTargetName, entry->pszTargetName))
674 {
675 found = TRUE;
676 HeapFree(GetProcessHeap(), 0, entry->pszUsername);
677 ZeroMemory(entry->pszPassword, (strlenW(entry->pszPassword) + 1) * sizeof(WCHAR));
678 HeapFree(GetProcessHeap(), 0, entry->pszPassword);
679 }
680
681 if (!found)
682 {
683 entry = HeapAlloc(GetProcessHeap(), 0, sizeof(*entry));
684 len = strlenW(pszTargetName);
685 entry->pszTargetName = HeapAlloc(GetProcessHeap(), 0, (len + 1)*sizeof(WCHAR));
686 memcpy(entry->pszTargetName, pszTargetName, (len + 1)*sizeof(WCHAR));
687 list_add_tail(&pending_credentials_list, &entry->entry);
688 }
689
690 len = strlenW(params.pszUsername);
691 entry->pszUsername = HeapAlloc(GetProcessHeap(), 0, (len + 1)*sizeof(WCHAR));
692 memcpy(entry->pszUsername, params.pszUsername, (len + 1)*sizeof(WCHAR));
693 len = strlenW(params.pszPassword);
694 entry->pszPassword = HeapAlloc(GetProcessHeap(), 0, (len + 1)*sizeof(WCHAR));
695 memcpy(entry->pszPassword, params.pszPassword, (len + 1)*sizeof(WCHAR));
696 entry->generic = (dwFlags & CREDUI_FLAGS_GENERIC_CREDENTIALS) != 0;
697
698 LeaveCriticalSection(&csPendingCredentials);
699 }
700 else if (!(dwFlags & CREDUI_FLAGS_DO_NOT_PERSIST))
701 result = save_credentials(pszTargetName, pszUsername, pszPassword,
702 (dwFlags & CREDUI_FLAGS_GENERIC_CREDENTIALS) != 0);
703 }
704
705 return result;
706 }
707
708 /******************************************************************************
709 * CredUIConfirmCredentialsW [CREDUI.@]
710 */
711 DWORD WINAPI CredUIConfirmCredentialsW(PCWSTR pszTargetName, BOOL bConfirm)
712 {
713 struct pending_credentials *entry;
714 DWORD result = ERROR_NOT_FOUND;
715
716 TRACE("(%s, %s)\n", debugstr_w(pszTargetName), bConfirm ? "TRUE" : "FALSE");
717
718 if (!pszTargetName)
719 return ERROR_INVALID_PARAMETER;
720
721 EnterCriticalSection(&csPendingCredentials);
722
723 LIST_FOR_EACH_ENTRY(entry, &pending_credentials_list, struct pending_credentials, entry)
724 {
725 if (!strcmpW(pszTargetName, entry->pszTargetName))
726 {
727 if (bConfirm)
728 result = save_credentials(entry->pszTargetName, entry->pszUsername,
729 entry->pszPassword, entry->generic);
730 else
731 result = ERROR_SUCCESS;
732
733 list_remove(&entry->entry);
734
735 HeapFree(GetProcessHeap(), 0, entry->pszTargetName);
736 HeapFree(GetProcessHeap(), 0, entry->pszUsername);
737 ZeroMemory(entry->pszPassword, (strlenW(entry->pszPassword) + 1) * sizeof(WCHAR));
738 HeapFree(GetProcessHeap(), 0, entry->pszPassword);
739 HeapFree(GetProcessHeap(), 0, entry);
740
741 break;
742 }
743 }
744
745 LeaveCriticalSection(&csPendingCredentials);
746
747 return result;
748 }
749
750 /******************************************************************************
751 * CredUIParseUserNameW [CREDUI.@]
752 */
753 DWORD WINAPI CredUIParseUserNameW(PCWSTR pszUserName, PWSTR pszUser,
754 ULONG ulMaxUserChars, PWSTR pszDomain,
755 ULONG ulMaxDomainChars)
756 {
757 PWSTR p;
758
759 TRACE("(%s, %p, %d, %p, %d)\n", debugstr_w(pszUserName), pszUser,
760 ulMaxUserChars, pszDomain, ulMaxDomainChars);
761
762 if (!pszUserName || !pszUser || !ulMaxUserChars || !pszDomain ||
763 !ulMaxDomainChars)
764 return ERROR_INVALID_PARAMETER;
765
766 /* FIXME: handle marshaled credentials */
767
768 p = strchrW(pszUserName, '\\');
769 if (p)
770 {
771 if (p - pszUserName > ulMaxDomainChars - 1)
772 return ERROR_INSUFFICIENT_BUFFER;
773 if (strlenW(p + 1) > ulMaxUserChars - 1)
774 return ERROR_INSUFFICIENT_BUFFER;
775 strcpyW(pszUser, p + 1);
776 memcpy(pszDomain, pszUserName, (p - pszUserName)*sizeof(WCHAR));
777 pszDomain[p - pszUserName] = '\0';
778
779 return ERROR_SUCCESS;
780 }
781
782 p = strrchrW(pszUserName, '@');
783 if (p)
784 {
785 if (p + 1 - pszUserName > ulMaxUserChars - 1)
786 return ERROR_INSUFFICIENT_BUFFER;
787 if (strlenW(p + 1) > ulMaxDomainChars - 1)
788 return ERROR_INSUFFICIENT_BUFFER;
789 strcpyW(pszDomain, p + 1);
790 memcpy(pszUser, pszUserName, (p - pszUserName)*sizeof(WCHAR));
791 pszUser[p - pszUserName] = '\0';
792
793 return ERROR_SUCCESS;
794 }
795
796 if (strlenW(pszUserName) > ulMaxUserChars - 1)
797 return ERROR_INSUFFICIENT_BUFFER;
798 strcpyW(pszUser, pszUserName);
799 pszDomain[0] = '\0';
800
801 return ERROR_SUCCESS;
802 }
803
804 /******************************************************************************
805 * CredUIStoreSSOCredA [CREDUI.@]
806 */
807 DWORD WINAPI CredUIStoreSSOCredA(PCSTR pszRealm, PCSTR pszUsername,
808 PCSTR pszPassword, BOOL bPersist)
809 {
810 FIXME("(%s, %s, %p, %d)\n", debugstr_a(pszRealm), debugstr_a(pszUsername),
811 pszPassword, bPersist);
812 return ERROR_SUCCESS;
813 }
814
815 /******************************************************************************
816 * CredUIStoreSSOCredW [CREDUI.@]
817 */
818 DWORD WINAPI CredUIStoreSSOCredW(PCWSTR pszRealm, PCWSTR pszUsername,
819 PCWSTR pszPassword, BOOL bPersist)
820 {
821 FIXME("(%s, %s, %p, %d)\n", debugstr_w(pszRealm), debugstr_w(pszUsername),
822 pszPassword, bPersist);
823 return ERROR_SUCCESS;
824 }
825
826 /******************************************************************************
827 * CredUIReadSSOCredA [CREDUI.@]
828 */
829 DWORD WINAPI CredUIReadSSOCredA(PCSTR pszRealm, PSTR *ppszUsername)
830 {
831 FIXME("(%s, %p)\n", debugstr_a(pszRealm), ppszUsername);
832 if (ppszUsername)
833 *ppszUsername = NULL;
834 return ERROR_NOT_FOUND;
835 }
836
837 /******************************************************************************
838 * CredUIReadSSOCredW [CREDUI.@]
839 */
840 DWORD WINAPI CredUIReadSSOCredW(PCWSTR pszRealm, PWSTR *ppszUsername)
841 {
842 FIXME("(%s, %p)\n", debugstr_w(pszRealm), ppszUsername);
843 if (ppszUsername)
844 *ppszUsername = NULL;
845 return ERROR_NOT_FOUND;
846 }
847
848 /******************************************************************************
849 * CredUIInitControls [CREDUI.@]
850 */
851 BOOL WINAPI CredUIInitControls(void)
852 {
853 FIXME("() stub\n");
854 return TRUE;
855 }
856
857 /******************************************************************************
858 * SspiPromptForCredentialsW [CREDUI.@]
859 */
860 ULONG SEC_ENTRY SspiPromptForCredentialsW( PCWSTR target, void *info,
861 DWORD error, PCWSTR package,
862 PSEC_WINNT_AUTH_IDENTITY_OPAQUE input_id,
863 PSEC_WINNT_AUTH_IDENTITY_OPAQUE *output_id,
864 BOOL *save, DWORD sspi_flags )
865 {
866 static const WCHAR basicW[] = {'B','a','s','i','c',0};
867 static const WCHAR ntlmW[] = {'N','T','L','M',0};
868 static const WCHAR negotiateW[] = {'N','e','g','o','t','i','a','t','e',0};
869 WCHAR username[CREDUI_MAX_USERNAME_LENGTH + 1] = {0};
870 WCHAR password[CREDUI_MAX_PASSWORD_LENGTH + 1] = {0};
871 DWORD len_username = sizeof(username) / sizeof(username[0]);
872 DWORD len_password = sizeof(password) / sizeof(password[0]);
873 DWORD ret, flags;
874 CREDUI_INFOW *cred_info = info;
875
876 FIXME( "(%s, %p, %u, %s, %p, %p, %p, %x) stub\n", debugstr_w(target), info,
877 error, debugstr_w(package), input_id, output_id, save, sspi_flags );
878
879 if (!target) return ERROR_INVALID_PARAMETER;
880 if (!package || (strcmpiW( package, basicW ) && strcmpiW( package, ntlmW ) &&
881 strcmpiW( package, negotiateW )))
882 {
883 FIXME( "package %s not supported\n", debugstr_w(package) );
884 return ERROR_NO_SUCH_PACKAGE;
885 }
886 if (input_id)
887 {
888 FIXME( "input identity not supported\n" );
889 return ERROR_CALL_NOT_IMPLEMENTED;
890 }
891
892 flags = CREDUI_FLAGS_ALWAYS_SHOW_UI | CREDUI_FLAGS_GENERIC_CREDENTIALS;
893
894 if (sspi_flags & SSPIPFC_CREDPROV_DO_NOT_SAVE)
895 flags |= CREDUI_FLAGS_DO_NOT_PERSIST;
896
897 if (!(sspi_flags & SSPIPFC_NO_CHECKBOX))
898 flags |= CREDUI_FLAGS_SHOW_SAVE_CHECK_BOX;
899
900 find_existing_credential( target, username, len_username, password, len_password );
901
902 if (!(ret = CredUIPromptForCredentialsW( cred_info, target, NULL, error, username,
903 len_username, password, len_password, save, flags )))
904 {
905 SEC_WINNT_AUTH_IDENTITY_W *id;
906 DWORD size = sizeof(*id);
907 WCHAR *ptr;
908
909 len_username = strlenW( username );
910 len_password = strlenW( password );
911
912 size += (len_username + 1) * sizeof(WCHAR);
913 size += (len_password + 1) * sizeof(WCHAR);
914 if (!(id = HeapAlloc( GetProcessHeap(), 0, size ))) return ERROR_OUTOFMEMORY;
915 ptr = (WCHAR *)(id + 1);
916
917 memcpy( ptr, username, (len_username + 1) * sizeof(WCHAR) );
918 id->User = ptr;
919 id->UserLength = len_username;
920 ptr += len_username + 1;
921 id->Domain = NULL;
922 id->DomainLength = 0;
923 memcpy( ptr, password, (len_password + 1) * sizeof(WCHAR) );
924 id->Password = ptr;
925 id->PasswordLength = len_password;
926 id->Flags = 0;
927
928 *output_id = id;
929 }
930
931 return ret;
932 }