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 struct pending_credentials
  39 {
  40     struct list entry;
  41     PWSTR pszTargetName;
  42     PWSTR pszUsername;
  43     PWSTR pszPassword;
  44     BOOL generic;
  45 };
  46
  47 static HINSTANCE hinstCredUI;
  48
  49 static struct list pending_credentials_list = LIST_INIT(pending_credentials_list);
  50
  51 static CRITICAL_SECTION csPendingCredentials;
  52 static CRITICAL_SECTION_DEBUG critsect_debug =
  53 {
  54     0, 0, &csPendingCredentials,
  55     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  56     0, 0, { (DWORD_PTR)(__FILE__ ": csPendingCredentials") }
  57 };
  58 static CRITICAL_SECTION csPendingCredentials = { &critsect_debug, -1, 0, 0, 0, 0 };
  59
  60
  61 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
  62 {
  63     TRACE("(0x%p, %d, %p)\n",hinstDLL,fdwReason,lpvReserved);
  64
  65     if (fdwReason == DLL_WINE_PREATTACH) return FALSE;  /* prefer native version */
  66
  67     if (fdwReason == DLL_PROCESS_ATTACH)
  68     {
  69         DisableThreadLibraryCalls(hinstDLL);
  70         hinstCredUI = hinstDLL;
  71         InitCommonControls();
  72     }
  73     else if (fdwReason == DLL_PROCESS_DETACH)
  74     {
  75         struct pending_credentials *entry, *cursor2;
  76         LIST_FOR_EACH_ENTRY_SAFE(entry, cursor2, &pending_credentials_list, struct pending_credentials, entry)
  77         {
  78             list_remove(&entry->entry);
  79
  80             HeapFree(GetProcessHeap(), 0, entry->pszTargetName);
  81             HeapFree(GetProcessHeap(), 0, entry->pszUsername);
  82             HeapFree(GetProcessHeap(), 0, entry->pszPassword);
  83             HeapFree(GetProcessHeap(), 0, entry);
  84         }
  85     }
  86
  87     return TRUE;
  88 }
  89
  90 static DWORD save_credentials(PCWSTR pszTargetName, PCWSTR pszUsername,
  91                               PCWSTR pszPassword, BOOL generic)
  92 {
  93     CREDENTIALW cred;
  94
  95     TRACE("saving servername %s with username %s\n", debugstr_w(pszTargetName), debugstr_w(pszUsername));
  96
  97     cred.Flags = 0;
  98     cred.Type = generic ? CRED_TYPE_GENERIC : CRED_TYPE_DOMAIN_PASSWORD;
  99     cred.TargetName = (LPWSTR)pszTargetName;
 100     cred.Comment = NULL;
 101     cred.CredentialBlobSize = strlenW(pszPassword) * sizeof(WCHAR);
 102     cred.CredentialBlob = (LPBYTE)pszPassword;
 103     cred.Persist = CRED_PERSIST_ENTERPRISE;
 104     cred.AttributeCount = 0;
 105     cred.Attributes = NULL;
 106     cred.TargetAlias = NULL;
 107     cred.UserName = (LPWSTR)pszUsername;
 108
 109     if (CredWriteW(&cred, 0))
 110         return ERROR_SUCCESS;
 111     else
 112     {
 113         DWORD ret = GetLastError();
 114         ERR("CredWriteW failed with error %d\n", ret);
 115         return ret;
 116     }
 117 }
 118
 119 struct cred_dialog_params
 120 {
 121     PCWSTR pszTargetName;
 122     PCWSTR pszMessageText;
 123     PCWSTR pszCaptionText;
 124     HBITMAP hbmBanner;
 125     PWSTR pszUsername;
 126     ULONG ulUsernameMaxChars;
 127     PWSTR pszPassword;
 128     ULONG ulPasswordMaxChars;
 129     BOOL fSave;
 130     DWORD dwFlags;
 131 };
 132
 133 static void CredDialogFillUsernameCombo(HWND hwndUsername, struct cred_dialog_params *params)
 134 {
 135     DWORD count;
 136     DWORD i;
 137     PCREDENTIALW *credentials;
 138
 139     if (!CredEnumerateW(NULL, 0, &count, &credentials))
 140         return;
 141
 142     for (i = 0; i < count; i++)
 143     {
 144         COMBOBOXEXITEMW comboitem;
 145
 146         if (params->dwFlags & CREDUI_FLAGS_GENERIC_CREDENTIALS)
 147         {
 148             if ((credentials[i]->Type != CRED_TYPE_GENERIC) || !credentials[i]->UserName)
 149                 continue;
 150         }
 151         else
 152         {
 153             if (credentials[i]->Type == CRED_TYPE_GENERIC)
 154                 continue;
 155         }
 156
 157         comboitem.mask = CBEIF_TEXT;
 158         comboitem.iItem = -1;
 159         comboitem.pszText = credentials[i]->UserName;
 160         SendMessageW(hwndUsername, CBEM_INSERTITEMW, 0, (LPARAM)&comboitem);
 161     }
 162
 163     CredFree(credentials);
 164 }
 165
 166 static BOOL CredDialogInit(HWND hwndDlg, struct cred_dialog_params *params)
 167 {
 168     HWND hwndUsername = GetDlgItem(hwndDlg, IDC_USERNAME);
 169     HWND hwndPassword = GetDlgItem(hwndDlg, IDC_PASSWORD);
 170
 171     SetWindowLongPtrW(hwndDlg, DWLP_USER, (LONG_PTR)params);
 172     if (params->pszMessageText)
 173         SetDlgItemTextW(hwndDlg, IDC_MESSAGE, params->pszMessageText);
 174     else
 175     {
 176         WCHAR format[256];
 177         WCHAR message[256];
 178         LoadStringW(hinstCredUI, IDS_MESSAGEFORMAT, format, sizeof(format)/sizeof(format[0]));
 179         snprintfW(message, sizeof(message)/sizeof(message[0]), format, params->pszTargetName);
 180         SetDlgItemTextW(hwndDlg, IDC_MESSAGE, message);
 181     }
 182     SetWindowTextW(hwndUsername, params->pszUsername);
 183     SetWindowTextW(hwndPassword, params->pszPassword);
 184
 185     CredDialogFillUsernameCombo(hwndUsername, params);
 186
 187     if (params->pszUsername[0])
 188         SetFocus(hwndPassword);
 189     else
 190         SetFocus(hwndUsername);
 191
 192     if (params->pszCaptionText)
 193         SetWindowTextW(hwndDlg, params->pszCaptionText);
 194     else
 195     {
 196         WCHAR format[256];
 197         WCHAR title[256];
 198         LoadStringW(hinstCredUI, IDS_TITLEFORMAT, format, sizeof(format)/sizeof(format[0]));
 199         snprintfW(title, sizeof(title)/sizeof(title[0]), format, params->pszTargetName);
 200         SetWindowTextW(hwndDlg, title);
 201     }
 202
 203     if (params->dwFlags & (CREDUI_FLAGS_DO_NOT_PERSIST|CREDUI_FLAGS_PERSIST))
 204         ShowWindow(GetDlgItem(hwndDlg, IDC_SAVE), SW_HIDE);
 205     else if (params->fSave)
 206         CheckDlgButton(hwndDlg, IDC_SAVE, BST_CHECKED);
 207
 208     return FALSE;
 209 }
 210
 211 static void CredDialogCommandOk(HWND hwndDlg, struct cred_dialog_params *params)
 212 {
 213     HWND hwndUsername = GetDlgItem(hwndDlg, IDC_USERNAME);
 214     LPWSTR user;
 215     INT len;
 216     INT len2;
 217
 218     len = GetWindowTextLengthW(hwndUsername);
 219     user = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
 220     GetWindowTextW(hwndUsername, user, len + 1);
 221
 222     if (!user[0])
 223     {
 224         HeapFree(GetProcessHeap(), 0, user);
 225         return;
 226     }
 227
 228     if (!strchrW(user, '\\') && !strchrW(user, '@'))
 229     {
 230         INT len_target = strlenW(params->pszTargetName);
 231         memcpy(params->pszUsername, params->pszTargetName,
 232                min(len_target, params->ulUsernameMaxChars) * sizeof(WCHAR));
 233         if (len_target + 1 < params->ulUsernameMaxChars)
 234             params->pszUsername[len_target] = '\\';
 235         if (len_target + 2 < params->ulUsernameMaxChars)
 236             params->pszUsername[len_target + 1] = '\0';
 237     }
 238     else if (params->ulUsernameMaxChars > 0)
 239         params->pszUsername[0] = '\0';
 240
 241     len2 = strlenW(params->pszUsername);
 242     memcpy(params->pszUsername + len2, user, min(len, params->ulUsernameMaxChars - len2) * sizeof(WCHAR));
 243     if (params->ulUsernameMaxChars)
 244         params->pszUsername[len2 + min(len, params->ulUsernameMaxChars - len2 - 1)] = '\0';
 245
 246     HeapFree(GetProcessHeap(), 0, user);
 247
 248     GetDlgItemTextW(hwndDlg, IDC_PASSWORD, params->pszPassword,
 249                     params->ulPasswordMaxChars);
 250
 251     EndDialog(hwndDlg, IDOK);
 252 }
 253
 254 static INT_PTR CALLBACK CredDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,
 255                                        LPARAM lParam)
 256 {
 257     switch (uMsg)
 258     {
 259         case WM_INITDIALOG:
 260         {
 261             struct cred_dialog_params *params = (struct cred_dialog_params *)lParam;
 262
 263             return CredDialogInit(hwndDlg, params);
 264         }
 265         case WM_COMMAND:
 266             switch (wParam)
 267             {
 268                 case MAKELONG(IDOK, BN_CLICKED):
 269                 {
 270                     struct cred_dialog_params *params =
 271                         (struct cred_dialog_params *)GetWindowLongPtrW(hwndDlg, DWLP_USER);
 272                     CredDialogCommandOk(hwndDlg, params);
 273                     return TRUE;
 274                 }
 275                 case MAKELONG(IDCANCEL, BN_CLICKED):
 276                     EndDialog(hwndDlg, IDCANCEL);
 277                     return TRUE;
 278             }
 279             /* fall through */
 280         default:
 281             return FALSE;
 282     }
 283 }
 284
 285 /******************************************************************************
 286  *           CredUIPromptForCredentialsW [CREDUI.@]
 287  */
 288 DWORD WINAPI CredUIPromptForCredentialsW(PCREDUI_INFOW pUIInfo,
 289                                          PCWSTR pszTargetName,
 290                                          PCtxtHandle Reserved,
 291                                          DWORD dwAuthError,
 292                                          PWSTR pszUsername,
 293                                          ULONG ulUsernameMaxChars,
 294                                          PWSTR pszPassword,
 295                                          ULONG ulPasswordMaxChars, PBOOL pfSave,
 296                                          DWORD dwFlags)
 297 {
 298     INT_PTR ret;
 299     struct cred_dialog_params params;
 300     DWORD result = ERROR_SUCCESS;
 301
 302     TRACE("(%p, %s, %p, %d, %s, %d, %p, %d, %p, 0x%08x)\n", pUIInfo,
 303           debugstr_w(pszTargetName), Reserved, dwAuthError, debugstr_w(pszUsername),
 304           ulUsernameMaxChars, pszPassword, ulPasswordMaxChars, pfSave, dwFlags);
 305
 306     if ((dwFlags & (CREDUI_FLAGS_ALWAYS_SHOW_UI|CREDUI_FLAGS_GENERIC_CREDENTIALS)) == CREDUI_FLAGS_ALWAYS_SHOW_UI)
 307         return ERROR_INVALID_FLAGS;
 308
 309     if (!pszTargetName)
 310         return ERROR_INVALID_PARAMETER;
 311
 312     if ((dwFlags & CREDUI_FLAGS_SHOW_SAVE_CHECK_BOX) && !pfSave)
 313         return ERROR_INVALID_PARAMETER;
 314
 315     params.pszTargetName = pszTargetName;
 316     if (pUIInfo)
 317     {
 318         params.pszMessageText = pUIInfo->pszMessageText;
 319         params.pszCaptionText = pUIInfo->pszCaptionText;
 320         params.hbmBanner  = pUIInfo->hbmBanner;
 321     }
 322     else
 323     {
 324         params.pszMessageText = NULL;
 325         params.pszCaptionText = NULL;
 326         params.hbmBanner = NULL;
 327     }
 328     params.pszUsername = pszUsername;
 329     params.ulUsernameMaxChars = ulUsernameMaxChars;
 330     params.pszPassword = pszPassword;
 331     params.ulPasswordMaxChars = ulPasswordMaxChars;
 332     params.fSave = pfSave ? *pfSave : FALSE;
 333     params.dwFlags = dwFlags;
 334
 335     ret = DialogBoxParamW(hinstCredUI, MAKEINTRESOURCEW(IDD_CREDDIALOG),
 336                           pUIInfo ? pUIInfo->hwndParent : NULL,
 337                           CredDialogProc, (LPARAM)&params);
 338     if (ret <= 0)
 339         return GetLastError();
 340
 341     if (ret == IDCANCEL)
 342     {
 343         TRACE("dialog cancelled\n");
 344         return ERROR_CANCELLED;
 345     }
 346
 347     if (pfSave)
 348         *pfSave = params.fSave;
 349
 350     if (params.fSave)
 351     {
 352         if (dwFlags & CREDUI_FLAGS_EXPECT_CONFIRMATION)
 353         {
 354             BOOL found = FALSE;
 355             struct pending_credentials *entry;
 356             int len;
 357
 358             EnterCriticalSection(&csPendingCredentials);
 359
 360             /* find existing pending credentials for the same target and overwrite */
 361             /* FIXME: is this correct? */
 362             LIST_FOR_EACH_ENTRY(entry, &pending_credentials_list, struct pending_credentials, entry)
 363                 if (!strcmpW(pszTargetName, entry->pszTargetName))
 364                 {
 365                     found = TRUE;
 366                     HeapFree(GetProcessHeap(), 0, entry->pszUsername);
 367                     HeapFree(GetProcessHeap(), 0, entry->pszPassword);
 368                 }
 369
 370             if (!found)
 371             {
 372                 entry = HeapAlloc(GetProcessHeap(), 0, sizeof(*entry));
 373                 list_init(&entry->entry);
 374                 len = strlenW(pszTargetName);
 375                 entry->pszTargetName = HeapAlloc(GetProcessHeap(), 0, (len + 1)*sizeof(WCHAR));
 376                 memcpy(entry->pszTargetName, pszTargetName, (len + 1)*sizeof(WCHAR));
 377                 list_add_tail(&entry->entry, &pending_credentials_list);
 378             }
 379
 380             len = strlenW(params.pszUsername);
 381             entry->pszUsername = HeapAlloc(GetProcessHeap(), 0, (len + 1)*sizeof(WCHAR));
 382             memcpy(entry->pszUsername, params.pszUsername, (len + 1)*sizeof(WCHAR));
 383             len = strlenW(params.pszPassword);
 384             entry->pszPassword = HeapAlloc(GetProcessHeap(), 0, (len + 1)*sizeof(WCHAR));
 385             memcpy(entry->pszPassword, params.pszPassword, (len + 1)*sizeof(WCHAR));
 386             entry->generic = dwFlags & CREDUI_FLAGS_GENERIC_CREDENTIALS ? TRUE : FALSE;
 387
 388             LeaveCriticalSection(&csPendingCredentials);
 389         }
 390         else
 391             result = save_credentials(pszTargetName, pszUsername, pszPassword,
 392                                       dwFlags & CREDUI_FLAGS_GENERIC_CREDENTIALS ? TRUE : FALSE);
 393     }
 394
 395     return result;
 396 }
 397
 398 /******************************************************************************
 399  *           CredUIConfirmCredentialsW [CREDUI.@]
 400  */
 401 DWORD WINAPI CredUIConfirmCredentialsW(PCWSTR pszTargetName, BOOL bConfirm)
 402 {
 403     struct pending_credentials *entry;
 404     DWORD result = ERROR_NOT_FOUND;
 405
 406     TRACE("(%s, %s)\n", debugstr_w(pszTargetName), bConfirm ? "TRUE" : "FALSE");
 407
 408     if (!pszTargetName)
 409         return ERROR_INVALID_PARAMETER;
 410
 411     EnterCriticalSection(&csPendingCredentials);
 412
 413     LIST_FOR_EACH_ENTRY(entry, &pending_credentials_list, struct pending_credentials, entry)
 414     {
 415         if (!strcmpW(pszTargetName, entry->pszTargetName))
 416         {
 417             if (bConfirm)
 418                 result = save_credentials(entry->pszTargetName, entry->pszUsername,
 419                                           entry->pszPassword, entry->generic);
 420             else
 421                 result = ERROR_SUCCESS;
 422
 423             list_remove(&entry->entry);
 424
 425             HeapFree(GetProcessHeap(), 0, entry->pszTargetName);
 426             HeapFree(GetProcessHeap(), 0, entry->pszUsername);
 427             HeapFree(GetProcessHeap(), 0, entry->pszPassword);
 428             HeapFree(GetProcessHeap(), 0, entry);
 429
 430             break;
 431         }
 432     }
 433
 434     LeaveCriticalSection(&csPendingCredentials);
 435
 436     return result;
 437 }
 438
 439 /******************************************************************************
 440  *           CredUIParseUserNameW [CREDUI.@]
 441  */
 442 DWORD WINAPI CredUIParseUserNameW(PCWSTR pszUserName, PWSTR pszUser,
 443                                   ULONG ulMaxUserChars, PWSTR pszDomain,
 444                                   ULONG ulMaxDomainChars)
 445 {
 446     PWSTR p;
 447
 448     TRACE("(%s, %p, %d, %p, %d)\n", debugstr_w(pszUserName), pszUser,
 449           ulMaxUserChars, pszDomain, ulMaxDomainChars);
 450
 451     if (!pszUserName || !pszUser || !ulMaxUserChars || !pszDomain ||
 452         !ulMaxDomainChars)
 453         return ERROR_INVALID_PARAMETER;
 454
 455     /* FIXME: handle marshaled credentials */
 456
 457     p = strchrW(pszUserName, '\\');
 458     if (p)
 459     {
 460         if (p - pszUserName > ulMaxDomainChars - 1)
 461             return ERROR_INSUFFICIENT_BUFFER;
 462         if (strlenW(p + 1) > ulMaxUserChars - 1)
 463             return ERROR_INSUFFICIENT_BUFFER;
 464         strcpyW(pszUser, p + 1);
 465         memcpy(pszDomain, pszUserName, (p - pszUserName)*sizeof(WCHAR));
 466         pszDomain[p - pszUserName] = '\0';
 467
 468         return ERROR_SUCCESS;
 469     }
 470
 471     p = strrchrW(pszUserName, '@');
 472     if (p)
 473     {
 474         if (p + 1 - pszUserName > ulMaxUserChars - 1)
 475             return ERROR_INSUFFICIENT_BUFFER;
 476         if (strlenW(p + 1) > ulMaxDomainChars - 1)
 477             return ERROR_INSUFFICIENT_BUFFER;
 478         strcpyW(pszDomain, p + 1);
 479         memcpy(pszUser, pszUserName, (p - pszUserName)*sizeof(WCHAR));
 480         pszUser[p - pszUserName] = '\0';
 481
 482         return ERROR_SUCCESS;
 483     }
 484
 485     if (strlenW(pszUserName) > ulMaxUserChars - 1)
 486         return ERROR_INSUFFICIENT_BUFFER;
 487     strcpyW(pszUser, pszUserName);
 488     pszDomain[0] = '\0';
 489
 490     return ERROR_SUCCESS;
 491 }
 492
 493 /******************************************************************************
 494  *           CredUIStoreSSOCredA [CREDUI.@]
 495  */
 496 DWORD WINAPI CredUIStoreSSOCredA(PCSTR pszRealm, PCSTR pszUsername,
 497                                  PCSTR pszPassword, BOOL bPersist)
 498 {
 499     FIXME("(%s, %s, %p, %d)\n", debugstr_a(pszRealm), debugstr_a(pszUsername),
 500           pszPassword, bPersist);
 501     return ERROR_SUCCESS;
 502 }
 503
 504 /******************************************************************************
 505  *           CredUIStoreSSOCredW [CREDUI.@]
 506  */
 507 DWORD WINAPI CredUIStoreSSOCredW(PCWSTR pszRealm, PCWSTR pszUsername,
 508                                  PCWSTR pszPassword, BOOL bPersist)
 509 {
 510     FIXME("(%s, %s, %p, %d)\n", debugstr_w(pszRealm), debugstr_w(pszUsername),
 511           pszPassword, bPersist);
 512     return ERROR_SUCCESS;
 513 }
 514
 515 /******************************************************************************
 516  *           CredUIReadSSOCredA [CREDUI.@]
 517  */
 518 DWORD WINAPI CredUIReadSSOCredA(PCSTR pszRealm, PSTR *ppszUsername)
 519 {
 520     FIXME("(%s, %p)\n", debugstr_a(pszRealm), ppszUsername);
 521     if (ppszUsername)
 522         *ppszUsername = NULL;
 523     return ERROR_NOT_FOUND;
 524 }
 525
 526 /******************************************************************************
 527  *           CredUIReadSSOCredW [CREDUI.@]
 528  */
 529 DWORD WINAPI CredUIReadSSOCredW(PCWSTR pszRealm, PWSTR *ppszUsername)
 530 {
 531     FIXME("(%s, %p)\n", debugstr_w(pszRealm), ppszUsername);
 532     if (ppszUsername)
 533         *ppszUsername = NULL;
 534     return ERROR_NOT_FOUND;
 535 }