git.oblomov.eu Git - wine/blob - dlls/cryptui/main.c

   1 /*
   2  * Copyright 2008 Juan Lang
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24 #define NONAMELESSUNION
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winnls.h"
  29 #include "winuser.h"
  30 #include "softpub.h"
  31 #include "wingdi.h"
  32 #include "richedit.h"
  33 #include "ole2.h"
  34 #include "richole.h"
  35 #include "commdlg.h"
  36 #include "commctrl.h"
  37 #include "cryptuiapi.h"
  38 #include "cryptuires.h"
  39 #include "urlmon.h"
  40 #include "hlink.h"
  41 #include "winreg.h"
  42 #include "wine/debug.h"
  43 #include "wine/unicode.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(cryptui);
  46
  47 static HINSTANCE hInstance;
  48
  49 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
  50 {
  51     TRACE("(0x%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);
  52
  53     switch (fdwReason)
  54     {
  55         case DLL_WINE_PREATTACH:
  56             return FALSE;    /* prefer native version */
  57         case DLL_PROCESS_ATTACH:
  58             hInstance = hinstDLL;
  59             DisableThreadLibraryCalls(hinstDLL);
  60             break;
  61         case DLL_PROCESS_DETACH:
  62             break;
  63         default:
  64             break;
  65     }
  66     return TRUE;
  67 }
  68
  69 #define MAX_STRING_LEN 512
  70
  71 static void add_cert_columns(HWND hwnd)
  72 {
  73     HWND lv = GetDlgItem(hwnd, IDC_MGR_CERTS);
  74     RECT rc;
  75     WCHAR buf[MAX_STRING_LEN];
  76     LVCOLUMNW column;
  77
  78     SendMessageW(lv, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
  79     GetWindowRect(lv, &rc);
  80     LoadStringW(hInstance, IDS_SUBJECT_COLUMN, buf,
  81      sizeof(buf) / sizeof(buf[0]));
  82     column.mask = LVCF_WIDTH | LVCF_TEXT;
  83     column.cx = (rc.right - rc.left) * 29 / 100 - 2;
  84     column.pszText = buf;
  85     SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
  86     LoadStringW(hInstance, IDS_ISSUER_COLUMN, buf,
  87      sizeof(buf) / sizeof(buf[0]));
  88     SendMessageW(lv, LVM_INSERTCOLUMNW, 1, (LPARAM)&column);
  89     column.cx = (rc.right - rc.left) * 16 / 100 - 2;
  90     LoadStringW(hInstance, IDS_EXPIRATION_COLUMN, buf,
  91      sizeof(buf) / sizeof(buf[0]));
  92     SendMessageW(lv, LVM_INSERTCOLUMNW, 2, (LPARAM)&column);
  93     column.cx = (rc.right - rc.left) * 23 / 100 - 1;
  94     LoadStringW(hInstance, IDS_FRIENDLY_NAME_COLUMN, buf,
  95      sizeof(buf) / sizeof(buf[0]));
  96     SendMessageW(lv, LVM_INSERTCOLUMNW, 3, (LPARAM)&column);
  97 }
  98
  99 static void add_cert_to_view(HWND lv, PCCERT_CONTEXT cert, DWORD *allocatedLen,
 100  LPWSTR *str)
 101 {
 102     DWORD len;
 103     LVITEMW item;
 104     WCHAR dateFmt[80]; /* sufficient for LOCALE_SSHORTDATE */
 105     WCHAR date[80];
 106     SYSTEMTIME sysTime;
 107
 108     item.mask = LVIF_IMAGE | LVIF_PARAM | LVIF_TEXT;
 109     item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
 110     item.iSubItem = 0;
 111     item.iImage = 0;
 112     item.lParam = (LPARAM)CertDuplicateCertificateContext(cert);
 113     len = CertGetNameStringW(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0, NULL,
 114      NULL, 0);
 115     if (len > *allocatedLen)
 116     {
 117         HeapFree(GetProcessHeap(), 0, *str);
 118         *str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 119         if (*str)
 120             *allocatedLen = len;
 121     }
 122     if (*str)
 123     {
 124         CertGetNameStringW(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0, NULL,
 125          *str, len);
 126         item.pszText = *str;
 127         SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
 128     }
 129
 130     item.mask = LVIF_TEXT;
 131     len = CertGetNameStringW(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
 132      CERT_NAME_ISSUER_FLAG, NULL, NULL, 0);
 133     if (len > *allocatedLen)
 134     {
 135         HeapFree(GetProcessHeap(), 0, *str);
 136         *str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 137         if (*str)
 138             *allocatedLen = len;
 139     }
 140     if (*str)
 141     {
 142         CertGetNameStringW(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
 143          CERT_NAME_ISSUER_FLAG, NULL, *str, len);
 144         item.pszText = *str;
 145         item.iSubItem = 1;
 146         SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
 147     }
 148
 149     GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SSHORTDATE, dateFmt,
 150      sizeof(dateFmt) / sizeof(dateFmt[0]));
 151     FileTimeToSystemTime(&cert->pCertInfo->NotAfter, &sysTime);
 152     GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, date,
 153      sizeof(date) / sizeof(date[0]));
 154     item.pszText = date;
 155     item.iSubItem = 2;
 156     SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
 157
 158     len = CertGetNameStringW(cert, CERT_NAME_FRIENDLY_DISPLAY_TYPE, 0, NULL,
 159      NULL, 0);
 160     if (len > *allocatedLen)
 161     {
 162         HeapFree(GetProcessHeap(), 0, *str);
 163         *str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 164         if (*str)
 165             *allocatedLen = len;
 166     }
 167     if (*str)
 168     {
 169         CertGetNameStringW(cert, CERT_NAME_FRIENDLY_DISPLAY_TYPE, 0, NULL,
 170          *str, len);
 171         item.pszText = *str;
 172         item.iSubItem = 3;
 173         SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
 174     }
 175 }
 176
 177 static LPSTR get_cert_mgr_usages(void)
 178 {
 179     static const WCHAR keyName[] = { 'S','o','f','t','w','a','r','e','\\','M',
 180      'i','c','r','o','s','o','f','t','\\','C','r','y','p','t','o','g','r','a',
 181      'p','h','y','\\','U','I','\\','C','e','r','t','m','g','r','\\','P','u',
 182      'r','p','o','s','e',0 };
 183     LPSTR str = NULL;
 184     HKEY key;
 185
 186     if (!RegCreateKeyExW(HKEY_CURRENT_USER, keyName, 0, NULL, 0, KEY_READ,
 187      NULL, &key, NULL))
 188     {
 189         LONG rc;
 190         DWORD type, size;
 191
 192         rc = RegQueryValueExA(key, "Purpose", NULL, &type, NULL, &size);
 193         if ((!rc || rc == ERROR_MORE_DATA) && type == REG_SZ)
 194         {
 195             str = HeapAlloc(GetProcessHeap(), 0, size);
 196             if (str)
 197             {
 198                 rc = RegQueryValueExA(key, "Purpose", NULL, NULL, (LPBYTE)str,
 199                  &size);
 200                 if (rc)
 201                 {
 202                     HeapFree(GetProcessHeap(), 0, str);
 203                     str = NULL;
 204                 }
 205             }
 206         }
 207         RegCloseKey(key);
 208     }
 209     return str;
 210 }
 211
 212 static void initialize_purpose_selection(HWND hwnd)
 213 {
 214     HWND cb = GetDlgItem(hwnd, IDC_MGR_PURPOSE_SELECTION);
 215     WCHAR buf[MAX_STRING_LEN];
 216     LPSTR usages;
 217
 218     LoadStringW(hInstance, IDS_PURPOSE_ALL, buf,
 219      sizeof(buf) / sizeof(buf[0]));
 220     SendMessageW(cb, CB_INSERTSTRING, -1, (LPARAM)buf);
 221     LoadStringW(hInstance, IDS_PURPOSE_ADVANCED, buf,
 222      sizeof(buf) / sizeof(buf[0]));
 223     SendMessageW(cb, CB_INSERTSTRING, -1, (LPARAM)buf);
 224     SendMessageW(cb, CB_SETCURSEL, 0, 0);
 225     if ((usages = get_cert_mgr_usages()))
 226     {
 227         LPSTR ptr, comma;
 228
 229         for (ptr = usages, comma = strchr(ptr, ','); ptr && *ptr;
 230          ptr = comma ? comma + 1 : NULL,
 231          comma = ptr ? strchr(ptr, ',') : NULL)
 232         {
 233             PCCRYPT_OID_INFO info;
 234
 235             if (comma)
 236                 *comma = 0;
 237             if ((info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, ptr, 0)))
 238                 SendMessageW(GetDlgItem(hwnd, IDC_MGR_PURPOSE_SELECTION),
 239                  CB_INSERTSTRING, 0, (LPARAM)info->pwszName);
 240         }
 241         HeapFree(GetProcessHeap(), 0, usages);
 242     }
 243 }
 244
 245 static void show_store_certs(HWND hwnd, HCERTSTORE store)
 246 {
 247     HWND lv = GetDlgItem(hwnd, IDC_MGR_CERTS);
 248     PCCERT_CONTEXT cert = NULL;
 249     DWORD allocatedLen = 0;
 250     LPWSTR str = NULL;
 251
 252     do {
 253         cert = CertEnumCertificatesInStore(store, cert);
 254         if (cert)
 255             add_cert_to_view(lv, cert, &allocatedLen, &str);
 256     } while (cert);
 257     HeapFree(GetProcessHeap(), 0, str);
 258 }
 259
 260 static const WCHAR my[] = { 'M','y',0 };
 261 static const WCHAR addressBook[] = {
 262  'A','d','d','r','e','s','s','B','o','o','k',0 };
 263 static const WCHAR ca[] = { 'C','A',0 };
 264 static const WCHAR root[] = { 'R','o','o','t',0 };
 265 static const WCHAR trustedPublisher[] = {
 266  'T','r','u','s','t','e','d','P','u','b','l','i','s','h','e','r',0 };
 267 static const WCHAR disallowed[] = { 'D','i','s','a','l','l','o','w','e','d',0 };
 268
 269 static LPCWSTR defaultStoreList[] = {
 270  my, addressBook, ca, root, trustedPublisher, disallowed };
 271 static LPCWSTR publisherStoreList[] = { root, trustedPublisher, disallowed };
 272
 273 static void show_cert_stores(HWND hwnd, DWORD dwFlags)
 274 {
 275     LPCWSTR *storeList;
 276     int cStores, i;
 277     HWND tab = GetDlgItem(hwnd, IDC_MGR_STORES);
 278
 279     if (dwFlags & CRYPTUI_CERT_MGR_PUBLISHER_TAB)
 280     {
 281         storeList = publisherStoreList;
 282         cStores = sizeof(publisherStoreList) / sizeof(publisherStoreList[0]);
 283     }
 284     else
 285     {
 286         storeList = defaultStoreList;
 287         cStores = sizeof(defaultStoreList) / sizeof(defaultStoreList[0]);
 288     }
 289     if (dwFlags & CRYPTUI_CERT_MGR_SINGLE_TAB_FLAG)
 290         cStores = 1;
 291     for (i = 0; i < cStores; i++)
 292     {
 293         LPCWSTR name;
 294         TCITEMW item;
 295         HCERTSTORE store;
 296
 297         if (!(name = CryptFindLocalizedName(storeList[i])))
 298             name = storeList[i];
 299         store = CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0,
 300          CERT_SYSTEM_STORE_CURRENT_USER, storeList[i]);
 301         item.mask = TCIF_TEXT | TCIF_PARAM;
 302         item.pszText = (LPWSTR)name;
 303         item.lParam = (LPARAM)store;
 304         SendMessageW(tab, TCM_INSERTITEMW, i, (LPARAM)&item);
 305     }
 306 }
 307
 308 static void free_certs(HWND lv)
 309 {
 310     LVITEMW item;
 311     int items = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0), i;
 312
 313     for (i = 0; i < items; i++)
 314     {
 315         item.mask = LVIF_PARAM;
 316         item.iItem = i;
 317         item.iSubItem = 0;
 318         SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item);
 319         CertFreeCertificateContext((PCCERT_CONTEXT)item.lParam);
 320     }
 321 }
 322
 323 static HCERTSTORE cert_mgr_index_to_store(HWND tab, int index)
 324 {
 325     TCITEMW item;
 326
 327     item.mask = TCIF_PARAM;
 328     SendMessageW(tab, TCM_GETITEMW, index, (LPARAM)&item);
 329     return (HCERTSTORE)item.lParam;
 330 }
 331
 332 static HCERTSTORE cert_mgr_current_store(HWND hwnd)
 333 {
 334     HWND tab = GetDlgItem(hwnd, IDC_MGR_STORES);
 335
 336     return cert_mgr_index_to_store(tab, SendMessageW(tab, TCM_GETCURSEL, 0, 0));
 337 }
 338
 339 static void close_stores(HWND tab)
 340 {
 341     int i, tabs = SendMessageW(tab, TCM_GETITEMCOUNT, 0, 0);
 342
 343     for (i = 0; i < tabs; i++)
 344         CertCloseStore(cert_mgr_index_to_store(tab, i), 0);
 345 }
 346
 347 static void refresh_store_certs(HWND hwnd)
 348 {
 349     HWND lv = GetDlgItem(hwnd, IDC_MGR_CERTS);
 350
 351     free_certs(lv);
 352     SendMessageW(lv, LVM_DELETEALLITEMS, 0, 0);
 353     show_store_certs(hwnd, cert_mgr_current_store(hwnd));
 354 }
 355
 356 typedef enum {
 357     CheckBitmapIndexUnchecked = 1,
 358     CheckBitmapIndexChecked = 2,
 359     CheckBitmapIndexDisabledUnchecked = 3,
 360     CheckBitmapIndexDisabledChecked = 4
 361 } CheckBitmapIndex;
 362
 363 static void add_known_usage(HWND lv, PCCRYPT_OID_INFO info,
 364  CheckBitmapIndex state)
 365 {
 366     LVITEMW item;
 367
 368     item.mask = LVIF_TEXT | LVIF_STATE | LVIF_PARAM;
 369     item.state = INDEXTOSTATEIMAGEMASK(state);
 370     item.stateMask = LVIS_STATEIMAGEMASK;
 371     item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
 372     item.iSubItem = 0;
 373     item.lParam = (LPARAM)info;
 374     item.pszText = (LPWSTR)info->pwszName;
 375     SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
 376 }
 377
 378 extern BOOL WINAPI WTHelperGetKnownUsages(DWORD action,
 379  PCCRYPT_OID_INFO **usages);
 380
 381 static void add_known_usages_to_list(HWND lv, CheckBitmapIndex state)
 382 {
 383     PCCRYPT_OID_INFO *usages;
 384
 385     if (WTHelperGetKnownUsages(1, &usages))
 386     {
 387         PCCRYPT_OID_INFO *ptr;
 388
 389         for (ptr = usages; *ptr; ptr++)
 390             add_known_usage(lv, *ptr, state);
 391         WTHelperGetKnownUsages(2, &usages);
 392     }
 393 }
 394
 395 static void toggle_usage(HWND hwnd, int iItem)
 396 {
 397     LVITEMW item;
 398     int res;
 399     HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
 400
 401     item.mask = LVIF_STATE;
 402     item.iItem = iItem;
 403     item.iSubItem = 0;
 404     item.stateMask = LVIS_STATEIMAGEMASK;
 405     res = SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item);
 406     if (res)
 407     {
 408         int state = item.state >> 12;
 409
 410         item.state = INDEXTOSTATEIMAGEMASK(
 411          state == CheckBitmapIndexChecked ? CheckBitmapIndexUnchecked :
 412          CheckBitmapIndexChecked);
 413         SendMessageW(lv, LVM_SETITEMSTATE, iItem, (LPARAM)&item);
 414     }
 415 }
 416
 417 static LONG_PTR find_oid_in_list(HWND lv, LPCSTR oid)
 418 {
 419     PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
 420      (void *)oid, CRYPT_ENHKEY_USAGE_OID_GROUP_ID);
 421     LONG_PTR ret;
 422
 423     if (oidInfo)
 424     {
 425         LVFINDINFOW findInfo;
 426
 427         findInfo.flags = LVFI_PARAM;
 428         findInfo.lParam = (LPARAM)oidInfo;
 429         ret = SendMessageW(lv, LVM_FINDITEMW, -1, (LPARAM)&findInfo);
 430     }
 431     else
 432     {
 433         LVFINDINFOA findInfo;
 434
 435         findInfo.flags = LVFI_STRING;
 436         findInfo.psz = oid;
 437         ret = SendMessageW(lv, LVM_FINDITEMA, -1, (LPARAM)&findInfo);
 438     }
 439     return ret;
 440 }
 441
 442 static void save_cert_mgr_usages(HWND hwnd)
 443 {
 444     static const WCHAR keyName[] = { 'S','o','f','t','w','a','r','e','\\','M',
 445      'i','c','r','o','s','o','f','t','\\','C','r','y','p','t','o','g','r','a',
 446      'p','h','y','\\','U','I','\\','C','e','r','t','m','g','r','\\','P','u',
 447      'r','p','o','s','e',0 };
 448     HKEY key;
 449     HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
 450     int purposes = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0), i;
 451     LVITEMW item;
 452     LPSTR str = NULL;
 453
 454     item.mask = LVIF_STATE | LVIF_PARAM;
 455     item.iSubItem = 0;
 456     item.stateMask = LVIS_STATEIMAGEMASK;
 457     for (i = 0; i < purposes; i++)
 458     {
 459         item.iItem = i;
 460         if (SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item))
 461         {
 462             int state = item.state >> 12;
 463
 464             if (state == CheckBitmapIndexUnchecked)
 465             {
 466                 CRYPT_OID_INFO *info = (CRYPT_OID_INFO *)item.lParam;
 467                 BOOL firstString = TRUE;
 468
 469                 if (!str)
 470                     str = HeapAlloc(GetProcessHeap(), 0,
 471                      strlen(info->pszOID) + 1);
 472                 else
 473                 {
 474                     str = HeapReAlloc(GetProcessHeap(), 0, str,
 475                      strlen(str) + 1 + strlen(info->pszOID) + 1);
 476                     firstString = FALSE;
 477                 }
 478                 if (str)
 479                 {
 480                     LPSTR ptr = firstString ? str : str + strlen(str);
 481
 482                     if (!firstString)
 483                         *ptr++ = ',';
 484                     strcpy(ptr, info->pszOID);
 485                 }
 486             }
 487         }
 488     }
 489     if (!RegCreateKeyExW(HKEY_CURRENT_USER, keyName, 0, NULL, 0, KEY_ALL_ACCESS,
 490      NULL, &key, NULL))
 491     {
 492         if (str)
 493             RegSetValueExA(key, "Purpose", 0, REG_SZ, (const BYTE *)str,
 494              strlen(str) + 1);
 495         else
 496             RegDeleteValueA(key, "Purpose");
 497         RegCloseKey(key);
 498     }
 499     HeapFree(GetProcessHeap(), 0, str);
 500 }
 501
 502 static LRESULT CALLBACK cert_mgr_advanced_dlg_proc(HWND hwnd, UINT msg,
 503  WPARAM wp, LPARAM lp)
 504 {
 505     switch (msg)
 506     {
 507     case WM_INITDIALOG:
 508     {
 509         RECT rc;
 510         LVCOLUMNW column;
 511         HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
 512         HIMAGELIST imageList;
 513         LPSTR disabledUsages;
 514
 515         GetWindowRect(lv, &rc);
 516         column.mask = LVCF_WIDTH;
 517         column.cx = rc.right - rc.left;
 518         SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
 519         imageList = ImageList_Create(16, 16, ILC_COLOR4 | ILC_MASK, 4, 0);
 520         if (imageList)
 521         {
 522             HBITMAP bmp;
 523             COLORREF backColor = RGB(255, 0, 255);
 524
 525             bmp = LoadBitmapW(hInstance, MAKEINTRESOURCEW(IDB_CHECKS));
 526             ImageList_AddMasked(imageList, bmp, backColor);
 527             DeleteObject(bmp);
 528             ImageList_SetBkColor(imageList, CLR_NONE);
 529             SendMessageW(lv, LVM_SETIMAGELIST, LVSIL_STATE, (LPARAM)imageList);
 530             SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)imageList);
 531         }
 532         add_known_usages_to_list(lv, CheckBitmapIndexChecked);
 533         if ((disabledUsages = get_cert_mgr_usages()))
 534         {
 535             LPSTR ptr, comma;
 536
 537             for (ptr = disabledUsages, comma = strchr(ptr, ','); ptr && *ptr;
 538              ptr = comma ? comma + 1 : NULL,
 539              comma = ptr ? strchr(ptr, ',') : NULL)
 540             {
 541                 LONG_PTR index;
 542
 543                 if (comma)
 544                     *comma = 0;
 545                 if ((index = find_oid_in_list(lv, ptr)) != -1)
 546                     toggle_usage(hwnd, index);
 547             }
 548             HeapFree(GetProcessHeap(), 0, disabledUsages);
 549         }
 550         break;
 551     }
 552     case WM_NOTIFY:
 553     {
 554         NMHDR *hdr = (NMHDR *)lp;
 555         NMITEMACTIVATE *nm;
 556
 557         switch (hdr->code)
 558         {
 559         case NM_CLICK:
 560             nm = (NMITEMACTIVATE *)lp;
 561             toggle_usage(hwnd, nm->iItem);
 562             SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
 563             break;
 564         }
 565         break;
 566     }
 567     case WM_COMMAND:
 568         switch (wp)
 569         {
 570         case IDOK:
 571             save_cert_mgr_usages(hwnd);
 572             ImageList_Destroy((HIMAGELIST)GetWindowLongPtrW(hwnd, DWLP_USER));
 573             EndDialog(hwnd, IDOK);
 574             break;
 575         case IDCANCEL:
 576             ImageList_Destroy((HIMAGELIST)GetWindowLongPtrW(hwnd, DWLP_USER));
 577             EndDialog(hwnd, IDCANCEL);
 578             break;
 579         }
 580         break;
 581     }
 582     return 0;
 583 }
 584
 585 static LRESULT CALLBACK cert_mgr_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
 586  LPARAM lp)
 587 {
 588     switch (msg)
 589     {
 590     case WM_INITDIALOG:
 591     {
 592         PCCRYPTUI_CERT_MGR_STRUCT pCryptUICertMgr =
 593          (PCCRYPTUI_CERT_MGR_STRUCT)lp;
 594         HIMAGELIST imageList;
 595         HWND tab = GetDlgItem(hwnd, IDC_MGR_STORES);
 596
 597         imageList = ImageList_Create(16, 16, ILC_COLOR4 | ILC_MASK, 2, 0);
 598         if (imageList)
 599         {
 600             HBITMAP bmp;
 601             COLORREF backColor = RGB(255, 0, 255);
 602
 603             bmp = LoadBitmapW(hInstance, MAKEINTRESOURCEW(IDB_SMALL_ICONS));
 604             ImageList_AddMasked(imageList, bmp, backColor);
 605             DeleteObject(bmp);
 606             ImageList_SetBkColor(imageList, CLR_NONE);
 607             SendMessageW(GetDlgItem(hwnd, IDC_MGR_CERTS), LVM_SETIMAGELIST,
 608              LVSIL_SMALL, (LPARAM)imageList);
 609             SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)imageList);
 610         }
 611         initialize_purpose_selection(hwnd);
 612         add_cert_columns(hwnd);
 613         if (pCryptUICertMgr->pwszTitle)
 614             SendMessageW(hwnd, WM_SETTEXT, 0,
 615              (LPARAM)pCryptUICertMgr->pwszTitle);
 616         show_cert_stores(hwnd, pCryptUICertMgr->dwFlags);
 617         show_store_certs(hwnd, cert_mgr_index_to_store(tab, 0));
 618         break;
 619     }
 620     case WM_NOTIFY:
 621     {
 622         NMHDR *hdr = (NMHDR *)lp;
 623
 624         switch (hdr->code)
 625         {
 626         case TCN_SELCHANGE:
 627             refresh_store_certs(hwnd);
 628             break;
 629         }
 630         break;
 631     }
 632     case WM_COMMAND:
 633         switch (wp)
 634         {
 635         case ((CBN_SELCHANGE << 16) | IDC_MGR_PURPOSE_SELECTION):
 636             refresh_store_certs(hwnd);
 637             break;
 638         case IDC_MGR_ADVANCED:
 639             DialogBoxW(hInstance, MAKEINTRESOURCEW(IDD_CERT_MGR_ADVANCED), hwnd,
 640              cert_mgr_advanced_dlg_proc);
 641             break;
 642         case IDCANCEL:
 643             free_certs(GetDlgItem(hwnd, IDC_MGR_CERTS));
 644             close_stores(GetDlgItem(hwnd, IDC_MGR_STORES));
 645             ImageList_Destroy((HIMAGELIST)GetWindowLongPtrW(hwnd, DWLP_USER));
 646             EndDialog(hwnd, IDCANCEL);
 647             break;
 648         }
 649         break;
 650     }
 651     return 0;
 652 }
 653
 654 /***********************************************************************
 655  *              CryptUIDlgCertMgr (CRYPTUI.@)
 656  */
 657 BOOL WINAPI CryptUIDlgCertMgr(PCCRYPTUI_CERT_MGR_STRUCT pCryptUICertMgr)
 658 {
 659     TRACE("(%p)\n", pCryptUICertMgr);
 660
 661     if (pCryptUICertMgr->dwSize != sizeof(CRYPTUI_CERT_MGR_STRUCT))
 662     {
 663         WARN("unexpected size %d\n", pCryptUICertMgr->dwSize);
 664         SetLastError(E_INVALIDARG);
 665         return FALSE;
 666     }
 667     DialogBoxParamW(hInstance, MAKEINTRESOURCEW(IDD_CERT_MGR),
 668      pCryptUICertMgr->hwndParent, cert_mgr_dlg_proc, (LPARAM)pCryptUICertMgr);
 669     return TRUE;
 670 }
 671
 672 /* FIXME: real names are unknown, functions are undocumented */
 673 typedef struct _CRYPTUI_ENUM_SYSTEM_STORE_ARGS
 674 {
 675     DWORD dwFlags;
 676     void *pvSystemStoreLocationPara;
 677 } CRYPTUI_ENUM_SYSTEM_STORE_ARGS, *PCRYPTUI_ENUM_SYSTEM_STORE_ARGS;
 678
 679 typedef struct _CRYPTUI_ENUM_DATA
 680 {
 681     DWORD                           cStores;
 682     HCERTSTORE                     *rghStore;
 683     DWORD                           cEnumArgs;
 684     PCRYPTUI_ENUM_SYSTEM_STORE_ARGS rgEnumArgs;
 685 } CRYPTUI_ENUM_DATA, *PCRYPTUI_ENUM_DATA;
 686
 687 typedef BOOL (WINAPI *PFN_SELECTED_STORE_CB)(HCERTSTORE store, HWND hwnd,
 688  void *pvArg);
 689
 690 /* Values for dwFlags */
 691 #define CRYPTUI_ENABLE_SHOW_PHYSICAL_STORE 0x00000001
 692
 693 typedef struct _CRYPTUI_SELECTSTORE_INFO_A
 694 {
 695     DWORD                 dwSize;
 696     HWND                  parent;
 697     DWORD                 dwFlags;
 698     LPSTR                 pszTitle;
 699     LPSTR                 pszText;
 700     CRYPTUI_ENUM_DATA    *pEnumData;
 701     PFN_SELECTED_STORE_CB pfnSelectedStoreCallback;
 702     void                 *pvArg;
 703 } CRYPTUI_SELECTSTORE_INFO_A, *PCRYPTUI_SELECTSTORE_INFO_A;
 704
 705 typedef struct _CRYPTUI_SELECTSTORE_INFO_W
 706 {
 707     DWORD                 dwSize;
 708     HWND                  parent;
 709     DWORD                 dwFlags;
 710     LPWSTR                pwszTitle;
 711     LPWSTR                pwszText;
 712     CRYPTUI_ENUM_DATA    *pEnumData;
 713     PFN_SELECTED_STORE_CB pfnSelectedStoreCallback;
 714     void                 *pvArg;
 715 } CRYPTUI_SELECTSTORE_INFO_W, *PCRYPTUI_SELECTSTORE_INFO_W;
 716
 717 struct StoreInfo
 718 {
 719     enum {
 720         StoreHandle,
 721         SystemStore
 722     } type;
 723     union {
 724         HCERTSTORE store;
 725         LPWSTR name;
 726     } DUMMYUNIONNAME;
 727 };
 728
 729 static BOOL WINAPI enum_store_callback(const void *pvSystemStore,
 730  DWORD dwFlags, PCERT_SYSTEM_STORE_INFO pStoreInfo, void *pvReserved,
 731  void *pvArg)
 732 {
 733     HWND tree = GetDlgItem(pvArg, IDC_STORE_LIST);
 734     TVINSERTSTRUCTW tvis;
 735     LPCWSTR localizedName;
 736     BOOL ret = TRUE;
 737
 738     tvis.hParent = NULL;
 739     tvis.hInsertAfter = TVI_LAST;
 740     tvis.u.item.mask = TVIF_TEXT;
 741     if ((localizedName = CryptFindLocalizedName(pvSystemStore)))
 742     {
 743         struct StoreInfo *storeInfo = HeapAlloc(GetProcessHeap(), 0,
 744          sizeof(struct StoreInfo));
 745
 746         if (storeInfo)
 747         {
 748             storeInfo->type = SystemStore;
 749             storeInfo->u.name = HeapAlloc(GetProcessHeap(), 0,
 750              (strlenW(pvSystemStore) + 1) * sizeof(WCHAR));
 751             if (storeInfo->u.name)
 752             {
 753                 tvis.u.item.mask |= TVIF_PARAM;
 754                 tvis.u.item.lParam = (LPARAM)storeInfo;
 755                 strcpyW(storeInfo->u.name, pvSystemStore);
 756             }
 757             else
 758             {
 759                 HeapFree(GetProcessHeap(), 0, storeInfo);
 760                 ret = FALSE;
 761             }
 762         }
 763         else
 764             ret = FALSE;
 765         tvis.u.item.pszText = (LPWSTR)localizedName;
 766     }
 767     else
 768         tvis.u.item.pszText = (LPWSTR)pvSystemStore;
 769     /* FIXME: need a folder icon for the store too */
 770     if (ret)
 771         SendMessageW(tree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
 772     return ret;
 773 }
 774
 775 static void enumerate_stores(HWND hwnd, CRYPTUI_ENUM_DATA *pEnumData)
 776 {
 777     DWORD i;
 778     HWND tree = GetDlgItem(hwnd, IDC_STORE_LIST);
 779
 780     for (i = 0; i < pEnumData->cEnumArgs; i++)
 781         CertEnumSystemStore(pEnumData->rgEnumArgs[i].dwFlags,
 782          pEnumData->rgEnumArgs[i].pvSystemStoreLocationPara,
 783          hwnd, enum_store_callback);
 784     for (i = 0; i < pEnumData->cStores; i++)
 785     {
 786         DWORD size;
 787
 788         if (CertGetStoreProperty(pEnumData->rghStore[i],
 789          CERT_STORE_LOCALIZED_NAME_PROP_ID, NULL, &size))
 790         {
 791             LPWSTR name = HeapAlloc(GetProcessHeap(), 0, size);
 792
 793             if (name)
 794             {
 795                 if (CertGetStoreProperty(pEnumData->rghStore[i],
 796                  CERT_STORE_LOCALIZED_NAME_PROP_ID, name, &size))
 797                 {
 798                     struct StoreInfo *storeInfo = HeapAlloc(GetProcessHeap(),
 799                      0, sizeof(struct StoreInfo));
 800
 801                     if (storeInfo)
 802                     {
 803                         TVINSERTSTRUCTW tvis;
 804
 805                         storeInfo->type = StoreHandle;
 806                         storeInfo->u.store = pEnumData->rghStore[i];
 807                         tvis.hParent = NULL;
 808                         tvis.hInsertAfter = TVI_LAST;
 809                         tvis.u.item.mask = TVIF_TEXT | TVIF_PARAM;
 810                         tvis.u.item.pszText = name;
 811                         tvis.u.item.lParam = (LPARAM)storeInfo;
 812                         SendMessageW(tree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
 813                     }
 814                 }
 815                 HeapFree(GetProcessHeap(), 0, name);
 816             }
 817         }
 818     }
 819 }
 820
 821 static void free_store_info(HWND tree)
 822 {
 823     HTREEITEM next = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM, TVGN_CHILD,
 824      (LPARAM)NULL);
 825
 826     while (next)
 827     {
 828         TVITEMW item;
 829
 830         memset(&item, 0, sizeof(item));
 831         item.mask = TVIF_HANDLE | TVIF_PARAM;
 832         item.hItem = next;
 833         SendMessageW(tree, TVM_GETITEMW, 0, (LPARAM)&item);
 834         if (item.lParam)
 835         {
 836             struct StoreInfo *storeInfo = (struct StoreInfo *)item.lParam;
 837
 838             if (storeInfo->type == SystemStore)
 839                 HeapFree(GetProcessHeap(), 0, storeInfo->u.name);
 840             HeapFree(GetProcessHeap(), 0, storeInfo);
 841         }
 842         next = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM, TVGN_NEXT,
 843          (LPARAM)next);
 844     }
 845 }
 846
 847 static HCERTSTORE selected_item_to_store(HWND tree, HTREEITEM hItem)
 848 {
 849     WCHAR buf[MAX_STRING_LEN];
 850     TVITEMW item;
 851     HCERTSTORE store;
 852
 853     memset(&item, 0, sizeof(item));
 854     item.mask = TVIF_HANDLE | TVIF_PARAM | TVIF_TEXT;
 855     item.hItem = hItem;
 856     item.cchTextMax = sizeof(buf) / sizeof(buf[0]);
 857     item.pszText = buf;
 858     SendMessageW(tree, TVM_GETITEMW, 0, (LPARAM)&item);
 859     if (item.lParam)
 860     {
 861         struct StoreInfo *storeInfo = (struct StoreInfo *)item.lParam;
 862
 863         if (storeInfo->type == StoreHandle)
 864             store = storeInfo->u.store;
 865         else
 866             store = CertOpenSystemStoreW(0, storeInfo->u.name);
 867     }
 868     else
 869     {
 870         /* It's implicitly a system store */
 871         store = CertOpenSystemStoreW(0, buf);
 872     }
 873     return store;
 874 }
 875
 876 struct SelectStoreInfo
 877 {
 878     PCRYPTUI_SELECTSTORE_INFO_W info;
 879     HCERTSTORE                  store;
 880 };
 881
 882 static LRESULT CALLBACK select_store_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
 883  LPARAM lp)
 884 {
 885     struct SelectStoreInfo *selectInfo;
 886     LRESULT ret = 0;
 887
 888     switch (msg)
 889     {
 890     case WM_INITDIALOG:
 891     {
 892         selectInfo = (struct SelectStoreInfo *)lp;
 893         SetWindowLongPtrW(hwnd, DWLP_USER, lp);
 894         if (selectInfo->info->pwszTitle)
 895             SendMessageW(hwnd, WM_SETTEXT, 0,
 896              (LPARAM)selectInfo->info->pwszTitle);
 897         if (selectInfo->info->pwszText)
 898             SendMessageW(GetDlgItem(hwnd, IDC_STORE_TEXT), WM_SETTEXT, 0,
 899              (LPARAM)selectInfo->info->pwszText);
 900         if (!(selectInfo->info->dwFlags & CRYPTUI_ENABLE_SHOW_PHYSICAL_STORE))
 901             ShowWindow(GetDlgItem(hwnd, IDC_SHOW_PHYSICAL_STORES), FALSE);
 902         enumerate_stores(hwnd, selectInfo->info->pEnumData);
 903         break;
 904     }
 905     case WM_COMMAND:
 906         switch (wp)
 907         {
 908         case IDOK:
 909         {
 910             HWND tree = GetDlgItem(hwnd, IDC_STORE_LIST);
 911             HTREEITEM selection = (HTREEITEM)SendMessageW(tree,
 912              TVM_GETNEXTITEM, TVGN_CARET, (LPARAM)NULL);
 913
 914             selectInfo = (struct SelectStoreInfo *)GetWindowLongPtrW(hwnd,
 915              DWLP_USER);
 916             if (!selection)
 917             {
 918                 WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN], *pTitle;
 919
 920                 if (selectInfo->info->pwszTitle)
 921                     pTitle = selectInfo->info->pwszTitle;
 922                 else
 923                 {
 924                     LoadStringW(hInstance, IDS_SELECT_STORE_TITLE, title,
 925                      sizeof(title) / sizeof(title[0]));
 926                     pTitle = title;
 927                 }
 928                 LoadStringW(hInstance, IDS_SELECT_STORE, error,
 929                  sizeof(error) / sizeof(error[0]));
 930                 MessageBoxW(hwnd, error, pTitle, MB_ICONEXCLAMATION | MB_OK);
 931             }
 932             else
 933             {
 934                 HCERTSTORE store = selected_item_to_store(tree, selection);
 935
 936                 if (!selectInfo->info->pfnSelectedStoreCallback ||
 937                  selectInfo->info->pfnSelectedStoreCallback(store, hwnd,
 938                  selectInfo->info->pvArg))
 939                 {
 940                     selectInfo->store = store;
 941                     free_store_info(tree);
 942                     EndDialog(hwnd, IDOK);
 943                 }
 944                 else
 945                     CertCloseStore(store, 0);
 946             }
 947             ret = TRUE;
 948             break;
 949         }
 950         case IDCANCEL:
 951             free_store_info(GetDlgItem(hwnd, IDC_STORE_LIST));
 952             EndDialog(hwnd, IDCANCEL);
 953             ret = TRUE;
 954             break;
 955         }
 956         break;
 957     }
 958     return ret;
 959 }
 960
 961 /***********************************************************************
 962  *              CryptUIDlgSelectStoreW (CRYPTUI.@)
 963  */
 964 HCERTSTORE WINAPI CryptUIDlgSelectStoreW(PCRYPTUI_SELECTSTORE_INFO_W info)
 965 {
 966     struct SelectStoreInfo selectInfo = { info, NULL };
 967
 968     TRACE("(%p)\n", info);
 969
 970     if (info->dwSize != sizeof(CRYPTUI_SELECTSTORE_INFO_W))
 971     {
 972         WARN("unexpected size %d\n", info->dwSize);
 973         SetLastError(E_INVALIDARG);
 974         return NULL;
 975     }
 976     DialogBoxParamW(hInstance, MAKEINTRESOURCEW(IDD_SELECT_STORE), info->parent,
 977      select_store_dlg_proc, (LPARAM)&selectInfo);
 978     return selectInfo.store;
 979 }
 980
 981 /***********************************************************************
 982  *              CryptUIDlgSelectStoreA (CRYPTUI.@)
 983  */
 984 HCERTSTORE WINAPI CryptUIDlgSelectStoreA(PCRYPTUI_SELECTSTORE_INFO_A info)
 985 {
 986     CRYPTUI_SELECTSTORE_INFO_W infoW;
 987     HCERTSTORE ret;
 988     int len;
 989
 990     TRACE("(%p)\n", info);
 991
 992     if (info->dwSize != sizeof(CRYPTUI_SELECTSTORE_INFO_A))
 993     {
 994         WARN("unexpected size %d\n", info->dwSize);
 995         SetLastError(E_INVALIDARG);
 996         return NULL;
 997     }
 998     memcpy(&infoW, &info, sizeof(info));
 999     if (info->pszTitle)
1000     {
1001         len = MultiByteToWideChar(CP_ACP, 0, info->pszTitle, -1, NULL, 0);
1002         infoW.pwszTitle = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1003         MultiByteToWideChar(CP_ACP, 0, info->pszTitle, -1, infoW.pwszTitle,
1004          len);
1005     }
1006     if (info->pszText)
1007     {
1008         len = MultiByteToWideChar(CP_ACP, 0, info->pszText, -1, NULL, 0);
1009         infoW.pwszText = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1010         MultiByteToWideChar(CP_ACP, 0, info->pszText, -1, infoW.pwszText, len);
1011     }
1012     ret = CryptUIDlgSelectStoreW(&infoW);
1013     HeapFree(GetProcessHeap(), 0, infoW.pwszText);
1014     HeapFree(GetProcessHeap(), 0, infoW.pwszTitle);
1015     return ret;
1016 }
1017
1018 /***********************************************************************
1019  *              CryptUIDlgViewCertificateA (CRYPTUI.@)
1020  */
1021 BOOL WINAPI CryptUIDlgViewCertificateA(
1022  PCCRYPTUI_VIEWCERTIFICATE_STRUCTA pCertViewInfo, BOOL *pfPropertiesChanged)
1023 {
1024     CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
1025     LPWSTR title = NULL;
1026     BOOL ret;
1027
1028     TRACE("(%p, %p)\n", pCertViewInfo, pfPropertiesChanged);
1029
1030     memcpy(&viewInfo, pCertViewInfo, sizeof(viewInfo));
1031     if (pCertViewInfo->szTitle)
1032     {
1033         int len = MultiByteToWideChar(CP_ACP, 0, pCertViewInfo->szTitle, -1,
1034          NULL, 0);
1035
1036         title = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1037         if (title)
1038         {
1039             MultiByteToWideChar(CP_ACP, 0, pCertViewInfo->szTitle, -1, title,
1040              len);
1041             viewInfo.szTitle = title;
1042         }
1043         else
1044         {
1045             ret = FALSE;
1046             goto error;
1047         }
1048     }
1049     if (pCertViewInfo->cPropSheetPages)
1050     {
1051         FIXME("ignoring additional prop sheet pages\n");
1052         viewInfo.cPropSheetPages = 0;
1053     }
1054     ret = CryptUIDlgViewCertificateW(&viewInfo, pfPropertiesChanged);
1055     HeapFree(GetProcessHeap(), 0, title);
1056 error:
1057     return ret;
1058 }
1059
1060 struct ReadStringStruct
1061 {
1062     LPCWSTR buf;
1063     LONG pos;
1064     LONG len;
1065 };
1066
1067 static DWORD CALLBACK read_text_callback(DWORD_PTR dwCookie, LPBYTE buf,
1068  LONG cb, LONG *pcb)
1069 {
1070     struct ReadStringStruct *string = (struct ReadStringStruct *)dwCookie;
1071     LONG cch = min(cb / sizeof(WCHAR), string->len - string->pos);
1072
1073     TRACE("(%p, %p, %d, %p)\n", string, buf, cb, pcb);
1074
1075     memmove(buf, string->buf + string->pos, cch * sizeof(WCHAR));
1076     string->pos += cch;
1077     *pcb = cch * sizeof(WCHAR);
1078     return 0;
1079 }
1080
1081 static void add_unformatted_text_to_control(HWND hwnd, LPCWSTR text, LONG len)
1082 {
1083     struct ReadStringStruct string;
1084     EDITSTREAM editstream;
1085
1086     TRACE("(%p, %s)\n", hwnd, debugstr_wn(text, len));
1087
1088     string.buf = text;
1089     string.pos = 0;
1090     string.len = len;
1091     editstream.dwCookie = (DWORD_PTR)&string;
1092     editstream.dwError = 0;
1093     editstream.pfnCallback = read_text_callback;
1094     SendMessageW(hwnd, EM_STREAMIN, SF_TEXT | SFF_SELECTION | SF_UNICODE,
1095      (LPARAM)&editstream);
1096 }
1097
1098 static void add_string_resource_to_control(HWND hwnd, int id)
1099 {
1100     LPWSTR str;
1101     LONG len;
1102
1103     len = LoadStringW(hInstance, id, (LPWSTR)&str, 0);
1104     add_unformatted_text_to_control(hwnd, str, len);
1105 }
1106
1107 static void add_text_with_paraformat_to_control(HWND hwnd, LPCWSTR text,
1108  LONG len, const PARAFORMAT2 *fmt)
1109 {
1110     add_unformatted_text_to_control(hwnd, text, len);
1111     SendMessageW(hwnd, EM_SETPARAFORMAT, 0, (LPARAM)fmt);
1112 }
1113
1114 static void add_string_resource_with_paraformat_to_control(HWND hwnd, int id,
1115  const PARAFORMAT2 *fmt)
1116 {
1117     LPWSTR str;
1118     LONG len;
1119
1120     len = LoadStringW(hInstance, id, (LPWSTR)&str, 0);
1121     add_text_with_paraformat_to_control(hwnd, str, len, fmt);
1122 }
1123
1124 static LPWSTR get_cert_name_string(PCCERT_CONTEXT pCertContext, DWORD dwType,
1125  DWORD dwFlags)
1126 {
1127     LPWSTR buf = NULL;
1128     DWORD len;
1129
1130     len = CertGetNameStringW(pCertContext, dwType, dwFlags, NULL, NULL, 0);
1131     if (len)
1132     {
1133         buf = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1134         if (buf)
1135             CertGetNameStringW(pCertContext, dwType, dwFlags, NULL, buf, len);
1136     }
1137     return buf;
1138 }
1139
1140 static void add_cert_string_to_control(HWND hwnd, PCCERT_CONTEXT pCertContext,
1141  DWORD dwType, DWORD dwFlags)
1142 {
1143     LPWSTR name = get_cert_name_string(pCertContext, dwType, dwFlags);
1144
1145     if (name)
1146     {
1147         /* Don't include NULL-terminator in output */
1148         DWORD len = lstrlenW(name);
1149
1150         add_unformatted_text_to_control(hwnd, name, len);
1151         HeapFree(GetProcessHeap(), 0, name);
1152     }
1153 }
1154
1155 static void add_icon_to_control(HWND hwnd, int id)
1156 {
1157     HRESULT hr;
1158     LPRICHEDITOLE richEditOle = NULL;
1159     LPOLEOBJECT object = NULL;
1160     CLSID clsid;
1161     LPOLECACHE oleCache = NULL;
1162     FORMATETC formatEtc;
1163     DWORD conn;
1164     LPDATAOBJECT dataObject = NULL;
1165     HBITMAP bitmap = NULL;
1166     RECT rect;
1167     STGMEDIUM stgm;
1168     REOBJECT reObject;
1169
1170     TRACE("(%p, %d)\n", hwnd, id);
1171
1172     SendMessageW(hwnd, EM_GETOLEINTERFACE, 0, (LPARAM)&richEditOle);
1173     if (!richEditOle)
1174         goto end;
1175     hr = OleCreateDefaultHandler(&CLSID_NULL, NULL, &IID_IOleObject,
1176      (void**)&object);
1177     if (FAILED(hr))
1178         goto end;
1179     hr = IOleObject_GetUserClassID(object, &clsid);
1180     if (FAILED(hr))
1181         goto end;
1182     hr = IOleObject_QueryInterface(object, &IID_IOleCache, (void**)&oleCache);
1183     if (FAILED(hr))
1184         goto end;
1185     formatEtc.cfFormat = CF_BITMAP;
1186     formatEtc.ptd = NULL;
1187     formatEtc.dwAspect = DVASPECT_CONTENT;
1188     formatEtc.lindex = -1;
1189     formatEtc.tymed = TYMED_GDI;
1190     hr = IOleCache_Cache(oleCache, &formatEtc, 0, &conn);
1191     if (FAILED(hr))
1192         goto end;
1193     hr = IOleObject_QueryInterface(object, &IID_IDataObject,
1194      (void**)&dataObject);
1195     if (FAILED(hr))
1196         goto end;
1197     bitmap = LoadImageW(hInstance, MAKEINTRESOURCEW(id), IMAGE_BITMAP, 0, 0,
1198      LR_DEFAULTSIZE | LR_LOADTRANSPARENT);
1199     if (!bitmap)
1200         goto end;
1201     rect.left = rect.top = 0;
1202     rect.right = GetSystemMetrics(SM_CXICON);
1203     rect.bottom = GetSystemMetrics(SM_CYICON);
1204     stgm.tymed = TYMED_GDI;
1205     stgm.u.hBitmap = bitmap;
1206     stgm.pUnkForRelease = NULL;
1207     hr = IDataObject_SetData(dataObject, &formatEtc, &stgm, TRUE);
1208     if (FAILED(hr))
1209         goto end;
1210
1211     reObject.cbStruct = sizeof(reObject);
1212     reObject.cp = REO_CP_SELECTION;
1213     reObject.clsid = clsid;
1214     reObject.poleobj = object;
1215     reObject.pstg = NULL;
1216     reObject.polesite = NULL;
1217     reObject.sizel.cx = reObject.sizel.cy = 0;
1218     reObject.dvaspect = DVASPECT_CONTENT;
1219     reObject.dwFlags = 0;
1220     reObject.dwUser = 0;
1221
1222     IRichEditOle_InsertObject(richEditOle, &reObject);
1223
1224 end:
1225     if (dataObject)
1226         IDataObject_Release(dataObject);
1227     if (oleCache)
1228         IOleCache_Release(oleCache);
1229     if (object)
1230         IOleObject_Release(object);
1231     if (richEditOle)
1232         IRichEditOle_Release(richEditOle);
1233 }
1234
1235 #define MY_INDENT 200
1236
1237 static void add_oid_text_to_control(HWND hwnd, char *oid)
1238 {
1239     WCHAR nl = '\n';
1240     PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, oid, 0);
1241     PARAFORMAT2 parFmt;
1242
1243     parFmt.cbSize = sizeof(parFmt);
1244     parFmt.dwMask = PFM_STARTINDENT;
1245     parFmt.dxStartIndent = MY_INDENT * 3;
1246     if (oidInfo)
1247     {
1248         add_text_with_paraformat_to_control(hwnd, oidInfo->pwszName,
1249          lstrlenW(oidInfo->pwszName), &parFmt);
1250         add_unformatted_text_to_control(hwnd, &nl, 1);
1251     }
1252 }
1253
1254 struct OIDToString
1255 {
1256     LPCSTR oid;
1257     int    id;
1258 };
1259
1260 /* The following list MUST be lexicographically sorted by OID */
1261 static struct OIDToString oidMap[] = {
1262  /* 1.3.6.1.4.1.311.10.3.1 */
1263  { szOID_KP_CTL_USAGE_SIGNING, IDS_PURPOSE_CTL_USAGE_SIGNING },
1264  /* 1.3.6.1.4.1.311.10.3.4 */
1265  { szOID_KP_EFS, IDS_PURPOSE_EFS },
1266  /* 1.3.6.1.4.1.311.10.3.4.1 */
1267  { szOID_EFS_RECOVERY, IDS_PURPOSE_EFS_RECOVERY },
1268  /* 1.3.6.1.4.1.311.10.3.5 */
1269  { szOID_WHQL_CRYPTO, IDS_PURPOSE_WHQL },
1270  /* 1.3.6.1.4.1.311.10.3.6 */
1271  { szOID_NT5_CRYPTO, IDS_PURPOSE_NT5 },
1272  /* 1.3.6.1.4.1.311.10.3.7 */
1273  { szOID_OEM_WHQL_CRYPTO, IDS_PURPOSE_OEM_WHQL },
1274  /* 1.3.6.1.4.1.311.10.3.8 */
1275  { szOID_EMBEDDED_NT_CRYPTO, IDS_PURPOSE_EMBEDDED_NT },
1276  /* 1.3.6.1.4.1.311.10.3.9 */
1277  { szOID_ROOT_LIST_SIGNER, IDS_PURPOSE_ROOT_LIST_SIGNER },
1278  /* 1.3.6.1.4.1.311.10.3.10 */
1279  { szOID_KP_QUALIFIED_SUBORDINATION, IDS_PURPOSE_QUALIFIED_SUBORDINATION },
1280  /* 1.3.6.1.4.1.311.10.3.11 */
1281  { szOID_KP_KEY_RECOVERY, IDS_PURPOSE_KEY_RECOVERY },
1282  /* 1.3.6.1.4.1.311.10.3.12 */
1283  { szOID_KP_DOCUMENT_SIGNING, IDS_PURPOSE_DOCUMENT_SIGNING },
1284  /* 1.3.6.1.4.1.311.10.3.13 */
1285  { szOID_KP_LIFETIME_SIGNING, IDS_PURPOSE_LIFETIME_SIGNING },
1286  /* 1.3.6.1.4.1.311.10.5.1 */
1287  { szOID_DRM, IDS_PURPOSE_DRM },
1288  /* 1.3.6.1.4.1.311.10.6.1 */
1289  { szOID_LICENSES, IDS_PURPOSE_LICENSES },
1290  /* 1.3.6.1.4.1.311.10.6.2 */
1291  { szOID_LICENSE_SERVER, IDS_PURPOSE_LICENSE_SERVER },
1292  /* 1.3.6.1.4.1.311.20.2.1 */
1293  { szOID_ENROLLMENT_AGENT, IDS_PURPOSE_ENROLLMENT_AGENT },
1294  /* 1.3.6.1.4.1.311.20.2.2 */
1295  { szOID_KP_SMARTCARD_LOGON, IDS_PURPOSE_SMARTCARD_LOGON },
1296  /* 1.3.6.1.4.1.311.21.5 */
1297  { szOID_KP_CA_EXCHANGE, IDS_PURPOSE_CA_EXCHANGE },
1298  /* 1.3.6.1.4.1.311.21.6 */
1299  { szOID_KP_KEY_RECOVERY_AGENT, IDS_PURPOSE_KEY_RECOVERY_AGENT },
1300  /* 1.3.6.1.4.1.311.21.19 */
1301  { szOID_DS_EMAIL_REPLICATION, IDS_PURPOSE_DS_EMAIL_REPLICATION },
1302  /* 1.3.6.1.5.5.7.3.1 */
1303  { szOID_PKIX_KP_SERVER_AUTH, IDS_PURPOSE_SERVER_AUTH },
1304  /* 1.3.6.1.5.5.7.3.2 */
1305  { szOID_PKIX_KP_CLIENT_AUTH, IDS_PURPOSE_CLIENT_AUTH },
1306  /* 1.3.6.1.5.5.7.3.3 */
1307  { szOID_PKIX_KP_CODE_SIGNING, IDS_PURPOSE_CODE_SIGNING },
1308  /* 1.3.6.1.5.5.7.3.4 */
1309  { szOID_PKIX_KP_EMAIL_PROTECTION, IDS_PURPOSE_EMAIL_PROTECTION },
1310  /* 1.3.6.1.5.5.7.3.5 */
1311  { szOID_PKIX_KP_IPSEC_END_SYSTEM, IDS_PURPOSE_IPSEC },
1312  /* 1.3.6.1.5.5.7.3.6 */
1313  { szOID_PKIX_KP_IPSEC_TUNNEL, IDS_PURPOSE_IPSEC },
1314  /* 1.3.6.1.5.5.7.3.7 */
1315  { szOID_PKIX_KP_IPSEC_USER, IDS_PURPOSE_IPSEC },
1316  /* 1.3.6.1.5.5.7.3.8 */
1317  { szOID_PKIX_KP_TIMESTAMP_SIGNING, IDS_PURPOSE_TIMESTAMP_SIGNING },
1318 };
1319
1320 static struct OIDToString *findSupportedOID(LPCSTR oid)
1321 {
1322     int indexHigh = sizeof(oidMap) / sizeof(oidMap[0]) - 1, indexLow = 0, i;
1323     struct OIDToString *ret = NULL;
1324
1325     for (i = (indexLow + indexHigh) / 2; !ret && indexLow <= indexHigh;
1326      i = (indexLow + indexHigh) / 2)
1327     {
1328         int cmp;
1329
1330         cmp = strcmp(oid, oidMap[i].oid);
1331         if (!cmp)
1332             ret = &oidMap[i];
1333         else if (cmp > 0)
1334             indexLow = i + 1;
1335         else
1336             indexHigh = i - 1;
1337     }
1338     return ret;
1339 }
1340
1341 static void add_local_oid_text_to_control(HWND text, LPCSTR oid)
1342 {
1343     struct OIDToString *entry;
1344     WCHAR nl = '\n';
1345     PARAFORMAT2 parFmt;
1346
1347     parFmt.cbSize = sizeof(parFmt);
1348     parFmt.dwMask = PFM_STARTINDENT;
1349     parFmt.dxStartIndent = MY_INDENT * 3;
1350     if ((entry = findSupportedOID(oid)))
1351     {
1352         WCHAR *str, *linebreak, *ptr;
1353         BOOL multiline = FALSE;
1354         int len;
1355
1356         len = LoadStringW(hInstance, entry->id, (LPWSTR)&str, 0);
1357         ptr = str;
1358         do {
1359             if ((linebreak = memchrW(ptr, '\n', len)))
1360             {
1361                 WCHAR copy[MAX_STRING_LEN];
1362
1363                 multiline = TRUE;
1364                 /* The source string contains a newline, which the richedit
1365                  * control won't find since it's interpreted as a paragraph
1366                  * break.  Therefore copy up to the newline.  lstrcpynW always
1367                  * NULL-terminates, so pass one more than the length of the
1368                  * source line so the copy includes the entire line and the
1369                  * NULL-terminator.
1370                  */
1371                 lstrcpynW(copy, ptr, linebreak - ptr + 1);
1372                 add_text_with_paraformat_to_control(text, copy,
1373                  linebreak - ptr, &parFmt);
1374                 ptr = linebreak + 1;
1375                 add_unformatted_text_to_control(text, &nl, 1);
1376             }
1377             else if (multiline && *ptr)
1378             {
1379                 /* Add the last line */
1380                 add_text_with_paraformat_to_control(text, ptr,
1381                  len - (ptr - str), &parFmt);
1382                 add_unformatted_text_to_control(text, &nl, 1);
1383             }
1384         } while (linebreak);
1385         if (!multiline)
1386         {
1387             add_text_with_paraformat_to_control(text, str, len, &parFmt);
1388             add_unformatted_text_to_control(text, &nl, 1);
1389         }
1390     }
1391     else
1392     {
1393         WCHAR *oidW = HeapAlloc(GetProcessHeap(), 0,
1394          (strlen(oid) + 1) * sizeof(WCHAR));
1395
1396         if (oidW)
1397         {
1398             LPCSTR src;
1399             WCHAR *dst;
1400
1401             for (src = oid, dst = oidW; *src; src++, dst++)
1402                 *dst = *src;
1403             *dst = 0;
1404             add_text_with_paraformat_to_control(text, oidW, lstrlenW(oidW),
1405              &parFmt);
1406             add_unformatted_text_to_control(text, &nl, 1);
1407             HeapFree(GetProcessHeap(), 0, oidW);
1408         }
1409     }
1410 }
1411
1412 static void display_app_usages(HWND text, PCCERT_CONTEXT cert,
1413  BOOL *anyUsageAdded)
1414 {
1415     static char any_app_policy[] = szOID_ANY_APPLICATION_POLICY;
1416     WCHAR nl = '\n';
1417     CHARFORMATW charFmt;
1418     PCERT_EXTENSION policyExt;
1419     if (!*anyUsageAdded)
1420     {
1421         PARAFORMAT2 parFmt;
1422
1423         parFmt.cbSize = sizeof(parFmt);
1424         parFmt.dwMask = PFM_STARTINDENT;
1425         parFmt.dxStartIndent = MY_INDENT;
1426         add_string_resource_with_paraformat_to_control(text,
1427          IDS_CERT_INFO_PURPOSES, &parFmt);
1428         add_unformatted_text_to_control(text, &nl, 1);
1429         *anyUsageAdded = TRUE;
1430     }
1431     memset(&charFmt, 0, sizeof(charFmt));
1432     charFmt.cbSize = sizeof(charFmt);
1433     charFmt.dwMask = CFM_BOLD;
1434     charFmt.dwEffects = 0;
1435     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
1436     if ((policyExt = CertFindExtension(szOID_APPLICATION_CERT_POLICIES,
1437      cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension)))
1438     {
1439         CERT_POLICIES_INFO *policies;
1440         DWORD size;
1441
1442         if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_CERT_POLICIES,
1443          policyExt->Value.pbData, policyExt->Value.cbData,
1444          CRYPT_DECODE_ALLOC_FLAG, NULL, &policies, &size))
1445         {
1446             DWORD i;
1447
1448             for (i = 0; i < policies->cPolicyInfo; i++)
1449             {
1450                 DWORD j;
1451
1452                 for (j = 0; j < policies->rgPolicyInfo[i].cPolicyQualifier; j++)
1453                     add_local_oid_text_to_control(text,
1454                      policies->rgPolicyInfo[i].rgPolicyQualifier[j].
1455                      pszPolicyQualifierId);
1456             }
1457             LocalFree(policies);
1458         }
1459     }
1460     else
1461         add_oid_text_to_control(text, any_app_policy);
1462 }
1463
1464 static BOOL display_cert_usages(HWND text, PCCERT_CONTEXT cert,
1465  BOOL *anyUsageAdded)
1466 {
1467     WCHAR nl = '\n';
1468     DWORD size;
1469     BOOL badUsages = FALSE;
1470
1471     if (CertGetEnhancedKeyUsage(cert, 0, NULL, &size))
1472     {
1473         CHARFORMATW charFmt;
1474         static char any_cert_policy[] = szOID_ANY_CERT_POLICY;
1475         PCERT_ENHKEY_USAGE usage = HeapAlloc(GetProcessHeap(), 0, size);
1476
1477         if (usage)
1478         {
1479             if (CertGetEnhancedKeyUsage(cert, 0, usage, &size))
1480             {
1481                 DWORD i;
1482
1483                 if (!*anyUsageAdded)
1484                 {
1485                     PARAFORMAT2 parFmt;
1486
1487                     parFmt.cbSize = sizeof(parFmt);
1488                     parFmt.dwMask = PFM_STARTINDENT;
1489                     parFmt.dxStartIndent = MY_INDENT;
1490                     add_string_resource_with_paraformat_to_control(text,
1491                      IDS_CERT_INFO_PURPOSES, &parFmt);
1492                     add_unformatted_text_to_control(text, &nl, 1);
1493                     *anyUsageAdded = TRUE;
1494                 }
1495                 memset(&charFmt, 0, sizeof(charFmt));
1496                 charFmt.cbSize = sizeof(charFmt);
1497                 charFmt.dwMask = CFM_BOLD;
1498                 charFmt.dwEffects = 0;
1499                 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION,
1500                  (LPARAM)&charFmt);
1501                 if (!usage->cUsageIdentifier)
1502                     add_oid_text_to_control(text, any_cert_policy);
1503                 else
1504                     for (i = 0; i < usage->cUsageIdentifier; i++)
1505                         add_local_oid_text_to_control(text,
1506                          usage->rgpszUsageIdentifier[i]);
1507             }
1508             else
1509                 badUsages = TRUE;
1510             HeapFree(GetProcessHeap(), 0, usage);
1511         }
1512         else
1513             badUsages = TRUE;
1514     }
1515     else
1516         badUsages = TRUE;
1517     return badUsages;
1518 }
1519
1520 static void set_policy_text(HWND text,
1521  PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
1522 {
1523     BOOL includeCertUsages = FALSE, includeAppUsages = FALSE;
1524     BOOL badUsages = FALSE, anyUsageAdded = FALSE;
1525
1526     if (pCertViewInfo->cPurposes)
1527     {
1528         DWORD i;
1529
1530         for (i = 0; i < pCertViewInfo->cPurposes; i++)
1531         {
1532             if (!strcmp(pCertViewInfo->rgszPurposes[i], szOID_ANY_CERT_POLICY))
1533                 includeCertUsages = TRUE;
1534             else if (!strcmp(pCertViewInfo->rgszPurposes[i],
1535              szOID_ANY_APPLICATION_POLICY))
1536                 includeAppUsages = TRUE;
1537             else
1538                 badUsages = TRUE;
1539         }
1540     }
1541     else
1542         includeAppUsages = includeCertUsages = TRUE;
1543     if (includeAppUsages)
1544         display_app_usages(text, pCertViewInfo->pCertContext, &anyUsageAdded);
1545     if (includeCertUsages)
1546         badUsages = display_cert_usages(text, pCertViewInfo->pCertContext,
1547          &anyUsageAdded);
1548     if (badUsages)
1549     {
1550         PARAFORMAT2 parFmt;
1551
1552         parFmt.cbSize = sizeof(parFmt);
1553         parFmt.dwMask = PFM_STARTINDENT;
1554         parFmt.dxStartIndent = MY_INDENT;
1555         add_string_resource_with_paraformat_to_control(text,
1556          IDS_CERT_INFO_BAD_PURPOSES, &parFmt);
1557     }
1558 }
1559
1560 static CRYPT_OBJID_BLOB *find_policy_qualifier(CERT_POLICIES_INFO *policies,
1561  LPCSTR policyOid)
1562 {
1563     CRYPT_OBJID_BLOB *ret = NULL;
1564     DWORD i;
1565
1566     for (i = 0; !ret && i < policies->cPolicyInfo; i++)
1567     {
1568         DWORD j;
1569
1570         for (j = 0; !ret && j < policies->rgPolicyInfo[i].cPolicyQualifier; j++)
1571             if (!strcmp(policies->rgPolicyInfo[i].rgPolicyQualifier[j].
1572              pszPolicyQualifierId, policyOid))
1573                 ret = &policies->rgPolicyInfo[i].rgPolicyQualifier[j].
1574                  Qualifier;
1575     }
1576     return ret;
1577 }
1578
1579 static WCHAR *get_cps_str_from_qualifier(CRYPT_OBJID_BLOB *qualifier)
1580 {
1581     LPWSTR qualifierStr = NULL;
1582     CERT_NAME_VALUE *qualifierValue;
1583     DWORD size;
1584
1585     if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_NAME_VALUE,
1586      qualifier->pbData, qualifier->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
1587      &qualifierValue, &size))
1588     {
1589         size = CertRDNValueToStrW(qualifierValue->dwValueType,
1590          &qualifierValue->Value, NULL, 0);
1591         qualifierStr = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
1592         if (qualifierStr)
1593             CertRDNValueToStrW(qualifierValue->dwValueType,
1594              &qualifierValue->Value, qualifierStr, size);
1595         LocalFree(qualifierValue);
1596     }
1597     return qualifierStr;
1598 }
1599
1600 static WCHAR *get_user_notice_from_qualifier(CRYPT_OBJID_BLOB *qualifier)
1601 {
1602     LPWSTR str = NULL;
1603     CERT_POLICY_QUALIFIER_USER_NOTICE *qualifierValue;
1604     DWORD size;
1605
1606     if (CryptDecodeObjectEx(X509_ASN_ENCODING,
1607      X509_PKIX_POLICY_QUALIFIER_USERNOTICE,
1608      qualifier->pbData, qualifier->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
1609      &qualifierValue, &size))
1610     {
1611         str = HeapAlloc(GetProcessHeap(), 0,
1612          (strlenW(qualifierValue->pszDisplayText) + 1) * sizeof(WCHAR));
1613         if (str)
1614             strcpyW(str, qualifierValue->pszDisplayText);
1615         LocalFree(qualifierValue);
1616     }
1617     return str;
1618 }
1619
1620 struct IssuerStatement
1621 {
1622     LPWSTR cps;
1623     LPWSTR userNotice;
1624 };
1625
1626 static void set_issuer_statement(HWND hwnd,
1627  PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
1628 {
1629     PCERT_EXTENSION policyExt;
1630
1631     if (!(pCertViewInfo->dwFlags & CRYPTUI_DISABLE_ISSUERSTATEMENT) &&
1632      (policyExt = CertFindExtension(szOID_CERT_POLICIES,
1633      pCertViewInfo->pCertContext->pCertInfo->cExtension,
1634      pCertViewInfo->pCertContext->pCertInfo->rgExtension)))
1635     {
1636         CERT_POLICIES_INFO *policies;
1637         DWORD size;
1638
1639         if (CryptDecodeObjectEx(X509_ASN_ENCODING, policyExt->pszObjId,
1640          policyExt->Value.pbData, policyExt->Value.cbData,
1641          CRYPT_DECODE_ALLOC_FLAG, NULL, &policies, &size))
1642         {
1643             CRYPT_OBJID_BLOB *qualifier;
1644             LPWSTR cps = NULL, userNotice = NULL;
1645
1646             if ((qualifier = find_policy_qualifier(policies,
1647              szOID_PKIX_POLICY_QUALIFIER_CPS)))
1648                 cps = get_cps_str_from_qualifier(qualifier);
1649             if ((qualifier = find_policy_qualifier(policies,
1650              szOID_PKIX_POLICY_QUALIFIER_USERNOTICE)))
1651                 userNotice = get_user_notice_from_qualifier(qualifier);
1652             if (cps || userNotice)
1653             {
1654                 struct IssuerStatement *issuerStatement =
1655                  HeapAlloc(GetProcessHeap(), 0, sizeof(struct IssuerStatement));
1656
1657                 if (issuerStatement)
1658                 {
1659                     issuerStatement->cps = cps;
1660                     issuerStatement->userNotice = userNotice;
1661                     EnableWindow(GetDlgItem(hwnd, IDC_ISSUERSTATEMENT), TRUE);
1662                     SetWindowLongPtrW(hwnd, DWLP_USER,
1663                      (ULONG_PTR)issuerStatement);
1664                 }
1665             }
1666             LocalFree(policies);
1667         }
1668     }
1669 }
1670
1671 static void set_cert_info(HWND hwnd,
1672  PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
1673 {
1674     CHARFORMATW charFmt;
1675     PARAFORMAT2 parFmt;
1676     HWND icon = GetDlgItem(hwnd, IDC_CERTIFICATE_ICON);
1677     HWND text = GetDlgItem(hwnd, IDC_CERTIFICATE_INFO);
1678     CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
1679      (CRYPT_PROVIDER_DATA *)pCertViewInfo->u.pCryptProviderData,
1680      pCertViewInfo->idxSigner, pCertViewInfo->fCounterSigner,
1681      pCertViewInfo->idxCounterSigner);
1682     CRYPT_PROVIDER_CERT *root =
1683      &provSigner->pasCertChain[provSigner->csCertChain - 1];
1684
1685     if (!provSigner->pChainContext ||
1686      (provSigner->pChainContext->TrustStatus.dwErrorStatus &
1687      CERT_TRUST_IS_PARTIAL_CHAIN))
1688         add_icon_to_control(icon, IDB_CERT_WARNING);
1689     else if (!root->fTrustedRoot)
1690         add_icon_to_control(icon, IDB_CERT_ERROR);
1691     else
1692         add_icon_to_control(icon, IDB_CERT);
1693
1694     memset(&charFmt, 0, sizeof(charFmt));
1695     charFmt.cbSize = sizeof(charFmt);
1696     charFmt.dwMask = CFM_BOLD;
1697     charFmt.dwEffects = CFE_BOLD;
1698     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
1699     /* FIXME: vertically center text */
1700     parFmt.cbSize = sizeof(parFmt);
1701     parFmt.dwMask = PFM_STARTINDENT;
1702     parFmt.dxStartIndent = MY_INDENT;
1703     add_string_resource_with_paraformat_to_control(text,
1704      IDS_CERTIFICATEINFORMATION, &parFmt);
1705
1706     text = GetDlgItem(hwnd, IDC_CERTIFICATE_STATUS);
1707     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
1708     if (provSigner->dwError == TRUST_E_CERT_SIGNATURE)
1709         add_string_resource_with_paraformat_to_control(text,
1710          IDS_CERT_INFO_BAD_SIG, &parFmt);
1711     else if (!provSigner->pChainContext ||
1712      (provSigner->pChainContext->TrustStatus.dwErrorStatus &
1713      CERT_TRUST_IS_PARTIAL_CHAIN))
1714         add_string_resource_with_paraformat_to_control(text,
1715          IDS_CERT_INFO_PARTIAL_CHAIN, &parFmt);
1716     else if (!root->fTrustedRoot)
1717     {
1718         if (provSigner->csCertChain == 1 && root->fSelfSigned)
1719             add_string_resource_with_paraformat_to_control(text,
1720              IDS_CERT_INFO_UNTRUSTED_CA, &parFmt);
1721         else
1722             add_string_resource_with_paraformat_to_control(text,
1723              IDS_CERT_INFO_UNTRUSTED_ROOT, &parFmt);
1724     }
1725     else
1726     {
1727         set_policy_text(text, pCertViewInfo);
1728         set_issuer_statement(hwnd, pCertViewInfo);
1729     }
1730 }
1731
1732 static void set_cert_name_string(HWND hwnd, PCCERT_CONTEXT cert,
1733  DWORD nameFlags, int heading)
1734 {
1735     WCHAR nl = '\n';
1736     HWND text = GetDlgItem(hwnd, IDC_CERTIFICATE_NAMES);
1737     CHARFORMATW charFmt;
1738     PARAFORMAT2 parFmt;
1739
1740     memset(&charFmt, 0, sizeof(charFmt));
1741     charFmt.cbSize = sizeof(charFmt);
1742     charFmt.dwMask = CFM_BOLD;
1743     charFmt.dwEffects = CFE_BOLD;
1744     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
1745     parFmt.cbSize = sizeof(parFmt);
1746     parFmt.dwMask = PFM_STARTINDENT;
1747     parFmt.dxStartIndent = MY_INDENT * 3;
1748     add_string_resource_with_paraformat_to_control(text, heading, &parFmt);
1749     charFmt.dwEffects = 0;
1750     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
1751     add_cert_string_to_control(text, cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
1752      nameFlags);
1753     add_unformatted_text_to_control(text, &nl, 1);
1754     add_unformatted_text_to_control(text, &nl, 1);
1755     add_unformatted_text_to_control(text, &nl, 1);
1756
1757 }
1758
1759 static void add_date_string_to_control(HWND hwnd, const FILETIME *fileTime)
1760 {
1761     WCHAR dateFmt[80]; /* sufficient for all versions of LOCALE_SSHORTDATE */
1762     WCHAR date[80];
1763     SYSTEMTIME sysTime;
1764
1765     GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SSHORTDATE, dateFmt,
1766      sizeof(dateFmt) / sizeof(dateFmt[0]));
1767     FileTimeToSystemTime(fileTime, &sysTime);
1768     GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, date,
1769      sizeof(date) / sizeof(date[0]));
1770     add_unformatted_text_to_control(hwnd, date, lstrlenW(date));
1771 }
1772
1773 static void set_cert_validity_period(HWND hwnd, PCCERT_CONTEXT cert)
1774 {
1775     WCHAR nl = '\n';
1776     HWND text = GetDlgItem(hwnd, IDC_CERTIFICATE_NAMES);
1777     CHARFORMATW charFmt;
1778     PARAFORMAT2 parFmt;
1779
1780     memset(&charFmt, 0, sizeof(charFmt));
1781     charFmt.cbSize = sizeof(charFmt);
1782     charFmt.dwMask = CFM_BOLD;
1783     charFmt.dwEffects = CFE_BOLD;
1784     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
1785     parFmt.cbSize = sizeof(parFmt);
1786     parFmt.dwMask = PFM_STARTINDENT;
1787     parFmt.dxStartIndent = MY_INDENT * 3;
1788     add_string_resource_with_paraformat_to_control(text, IDS_VALID_FROM,
1789      &parFmt);
1790     charFmt.dwEffects = 0;
1791     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
1792     add_date_string_to_control(text, &cert->pCertInfo->NotBefore);
1793     charFmt.dwEffects = CFE_BOLD;
1794     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
1795     add_string_resource_to_control(text, IDS_VALID_TO);
1796     charFmt.dwEffects = 0;
1797     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
1798     add_date_string_to_control(text, &cert->pCertInfo->NotAfter);
1799     add_unformatted_text_to_control(text, &nl, 1);
1800 }
1801
1802 static void set_general_info(HWND hwnd,
1803  PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
1804 {
1805     set_cert_info(hwnd, pCertViewInfo);
1806     set_cert_name_string(hwnd, pCertViewInfo->pCertContext, 0,
1807      IDS_SUBJECT_HEADING);
1808     set_cert_name_string(hwnd, pCertViewInfo->pCertContext,
1809      CERT_NAME_ISSUER_FLAG, IDS_ISSUER_HEADING);
1810     set_cert_validity_period(hwnd, pCertViewInfo->pCertContext);
1811 }
1812
1813 static LRESULT CALLBACK user_notice_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
1814  LPARAM lp)
1815 {
1816     LRESULT ret = 0;
1817     HWND text;
1818     struct IssuerStatement *issuerStatement;
1819
1820     switch (msg)
1821     {
1822     case WM_INITDIALOG:
1823         text = GetDlgItem(hwnd, IDC_USERNOTICE);
1824         issuerStatement = (struct IssuerStatement *)lp;
1825         add_unformatted_text_to_control(text, issuerStatement->userNotice,
1826          strlenW(issuerStatement->userNotice));
1827         if (issuerStatement->cps)
1828             SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)issuerStatement->cps);
1829         else
1830             EnableWindow(GetDlgItem(hwnd, IDC_CPS), FALSE);
1831         break;
1832     case WM_COMMAND:
1833         switch (wp)
1834         {
1835         case IDOK:
1836             EndDialog(hwnd, IDOK);
1837             ret = TRUE;
1838             break;
1839         case IDC_CPS:
1840         {
1841             IBindCtx *bctx = NULL;
1842             LPWSTR cps;
1843
1844             CreateBindCtx(0, &bctx);
1845             cps = (LPWSTR)GetWindowLongPtrW(hwnd, DWLP_USER);
1846             HlinkSimpleNavigateToString(cps, NULL, NULL, NULL, bctx, NULL,
1847              HLNF_OPENINNEWWINDOW, 0);
1848             IBindCtx_Release(bctx);
1849             break;
1850         }
1851         }
1852     }
1853     return ret;
1854 }
1855
1856 static void show_user_notice(HWND hwnd, struct IssuerStatement *issuerStatement)
1857 {
1858     DialogBoxParamW(hInstance, MAKEINTRESOURCEW(IDD_USERNOTICE), hwnd,
1859      user_notice_dlg_proc, (LPARAM)issuerStatement);
1860 }
1861
1862 static LRESULT CALLBACK general_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
1863  LPARAM lp)
1864 {
1865     PROPSHEETPAGEW *page;
1866     PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo;
1867
1868     TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
1869
1870     switch (msg)
1871     {
1872     case WM_INITDIALOG:
1873         page = (PROPSHEETPAGEW *)lp;
1874         pCertViewInfo = (PCCRYPTUI_VIEWCERTIFICATE_STRUCTW)page->lParam;
1875         if (pCertViewInfo->dwFlags & CRYPTUI_DISABLE_ADDTOSTORE)
1876             ShowWindow(GetDlgItem(hwnd, IDC_ADDTOSTORE), FALSE);
1877         EnableWindow(GetDlgItem(hwnd, IDC_ISSUERSTATEMENT), FALSE);
1878         set_general_info(hwnd, pCertViewInfo);
1879         break;
1880     case WM_COMMAND:
1881         switch (wp)
1882         {
1883         case IDC_ADDTOSTORE:
1884             CryptUIWizImport(0, hwnd, NULL, NULL, NULL);
1885             break;
1886         case IDC_ISSUERSTATEMENT:
1887         {
1888             struct IssuerStatement *issuerStatement =
1889              (struct IssuerStatement *)GetWindowLongPtrW(hwnd, DWLP_USER);
1890
1891             if (issuerStatement)
1892             {
1893                 if (issuerStatement->userNotice)
1894                     show_user_notice(hwnd, issuerStatement);
1895                 else if (issuerStatement->cps)
1896                 {
1897                     IBindCtx *bctx = NULL;
1898
1899                     CreateBindCtx(0, &bctx);
1900                     HlinkSimpleNavigateToString(issuerStatement->cps, NULL,
1901                      NULL, NULL, bctx, NULL, HLNF_OPENINNEWWINDOW, 0);
1902                     IBindCtx_Release(bctx);
1903                 }
1904             }
1905             break;
1906         }
1907         }
1908         break;
1909     }
1910     return 0;
1911 }
1912
1913 static UINT CALLBACK general_callback_proc(HWND hwnd, UINT msg,
1914  PROPSHEETPAGEW *page)
1915 {
1916     struct IssuerStatement *issuerStatement;
1917
1918     switch (msg)
1919     {
1920     case PSPCB_RELEASE:
1921         issuerStatement =
1922          (struct IssuerStatement *)GetWindowLongPtrW(hwnd, DWLP_USER);
1923         if (issuerStatement)
1924         {
1925             HeapFree(GetProcessHeap(), 0, issuerStatement->cps);
1926             HeapFree(GetProcessHeap(), 0, issuerStatement->userNotice);
1927             HeapFree(GetProcessHeap(), 0, issuerStatement);
1928         }
1929         break;
1930     }
1931     return 1;
1932 }
1933
1934 static void init_general_page(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
1935  PROPSHEETPAGEW *page)
1936 {
1937     memset(page, 0, sizeof(PROPSHEETPAGEW));
1938     page->dwSize = sizeof(PROPSHEETPAGEW);
1939     page->dwFlags = PSP_USECALLBACK;
1940     page->pfnCallback = general_callback_proc;
1941     page->hInstance = hInstance;
1942     page->u.pszTemplate = MAKEINTRESOURCEW(IDD_GENERAL);
1943     page->pfnDlgProc = general_dlg_proc;
1944     page->lParam = (LPARAM)pCertViewInfo;
1945 }
1946
1947 typedef WCHAR * (*field_format_func)(PCCERT_CONTEXT cert);
1948
1949 static WCHAR *field_format_version(PCCERT_CONTEXT cert)
1950 {
1951     static const WCHAR fmt[] = { 'V','%','d',0 };
1952     WCHAR *buf = HeapAlloc(GetProcessHeap(), 0, 12 * sizeof(WCHAR));
1953
1954     if (buf)
1955         sprintfW(buf, fmt, cert->pCertInfo->dwVersion);
1956     return buf;
1957 }
1958
1959 static WCHAR *format_hex_string(void *pb, DWORD cb)
1960 {
1961     WCHAR *buf = HeapAlloc(GetProcessHeap(), 0, (cb * 3 + 1) * sizeof(WCHAR));
1962
1963     if (buf)
1964     {
1965         static const WCHAR fmt[] = { '%','0','2','x',' ',0 };
1966         DWORD i;
1967         WCHAR *ptr;
1968
1969         for (i = 0, ptr = buf; i < cb; i++, ptr += 3)
1970             sprintfW(ptr, fmt, ((BYTE *)pb)[i]);
1971     }
1972     return buf;
1973 }
1974
1975 static WCHAR *field_format_serial_number(PCCERT_CONTEXT cert)
1976 {
1977     return format_hex_string(cert->pCertInfo->SerialNumber.pbData,
1978      cert->pCertInfo->SerialNumber.cbData);
1979 }
1980
1981 static WCHAR *field_format_issuer(PCCERT_CONTEXT cert)
1982 {
1983     return get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
1984      CERT_NAME_ISSUER_FLAG);
1985 }
1986
1987 static WCHAR *field_format_detailed_cert_name(PCERT_NAME_BLOB name)
1988 {
1989     WCHAR *str = NULL;
1990     DWORD len = CertNameToStrW(X509_ASN_ENCODING, name,
1991      CERT_X500_NAME_STR | CERT_NAME_STR_CRLF_FLAG, NULL, 0);
1992
1993     if (len)
1994     {
1995         str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1996         if (str)
1997             CertNameToStrW(X509_ASN_ENCODING, name,
1998              CERT_X500_NAME_STR | CERT_NAME_STR_CRLF_FLAG, str, len);
1999     }
2000     return str;
2001 }
2002
2003 static WCHAR *field_format_detailed_issuer(PCCERT_CONTEXT cert, void *param)
2004 {
2005     return field_format_detailed_cert_name(&cert->pCertInfo->Issuer);
2006 }
2007
2008 static WCHAR *field_format_subject(PCCERT_CONTEXT cert)
2009 {
2010     return get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0);
2011 }
2012
2013 static WCHAR *field_format_detailed_subject(PCCERT_CONTEXT cert, void *param)
2014 {
2015     return field_format_detailed_cert_name(&cert->pCertInfo->Subject);
2016 }
2017
2018 static WCHAR *format_long_date(const FILETIME *fileTime)
2019 {
2020     WCHAR dateFmt[80]; /* long enough for LOCALE_SLONGDATE */
2021     DWORD len;
2022     WCHAR *buf = NULL;
2023     SYSTEMTIME sysTime;
2024
2025     /* FIXME: format isn't quite right, want time too */
2026     GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SLONGDATE, dateFmt,
2027      sizeof(dateFmt) / sizeof(dateFmt[0]));
2028     FileTimeToSystemTime(fileTime, &sysTime);
2029     len = GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, NULL, 0);
2030     if (len)
2031     {
2032         buf = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2033         if (buf)
2034             GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, buf,
2035              len);
2036     }
2037     return buf;
2038 }
2039
2040 static WCHAR *field_format_from_date(PCCERT_CONTEXT cert)
2041 {
2042     return format_long_date(&cert->pCertInfo->NotBefore);
2043 }
2044
2045 static WCHAR *field_format_to_date(PCCERT_CONTEXT cert)
2046 {
2047     return format_long_date(&cert->pCertInfo->NotAfter);
2048 }
2049
2050 static WCHAR *field_format_public_key(PCCERT_CONTEXT cert)
2051 {
2052     PCCRYPT_OID_INFO oidInfo;
2053     WCHAR *buf = NULL;
2054
2055     oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
2056      cert->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId, 0);
2057     if (oidInfo)
2058     {
2059         WCHAR fmt[MAX_STRING_LEN];
2060
2061         if (LoadStringW(hInstance, IDS_FIELD_PUBLIC_KEY_FORMAT, fmt,
2062          sizeof(fmt) / sizeof(fmt[0])))
2063         {
2064             /* Allocate the output buffer.  Use the number of bytes in the
2065              * public key as a conservative (high) estimate for the number of
2066              * digits in its output.
2067              * The output is of the form (in English)
2068              * "<public key algorithm> (<public key bit length> bits)".
2069              * Ordinarily having two positional parameters in a string is not a
2070              * good idea, but as this isn't a sentence fragment, it shouldn't
2071              * be word-order dependent.
2072              */
2073             buf = HeapAlloc(GetProcessHeap(), 0,
2074              (strlenW(fmt) + strlenW(oidInfo->pwszName) +
2075              cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData * 8)
2076              * sizeof(WCHAR));
2077             if (buf)
2078                 sprintfW(buf, fmt, oidInfo->pwszName,
2079                  CertGetPublicKeyLength(X509_ASN_ENCODING,
2080                   &cert->pCertInfo->SubjectPublicKeyInfo));
2081         }
2082     }
2083     return buf;
2084 }
2085
2086 static WCHAR *field_format_detailed_public_key(PCCERT_CONTEXT cert, void *param)
2087 {
2088     return format_hex_string(
2089      cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.pbData,
2090      cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData);
2091 }
2092
2093 struct field_value_data;
2094 struct detail_data
2095 {
2096     PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo;
2097     BOOL *pfPropertiesChanged;
2098     int cFields;
2099     struct field_value_data *fields;
2100 };
2101
2102 typedef void (*add_fields_func)(HWND hwnd, struct detail_data *data);
2103
2104 typedef WCHAR *(*create_detailed_value_func)(PCCERT_CONTEXT cert, void *param);
2105
2106 struct field_value_data
2107 {
2108     create_detailed_value_func create;
2109     LPWSTR detailed_value;
2110     void *param;
2111 };
2112
2113 static void add_field_value_data(struct detail_data *data,
2114  create_detailed_value_func create, void *param)
2115 {
2116     if (data->cFields)
2117         data->fields = HeapReAlloc(GetProcessHeap(), 0, data->fields,
2118          (data->cFields + 1) * sizeof(struct field_value_data));
2119     else
2120         data->fields = HeapAlloc(GetProcessHeap(), 0,
2121          sizeof(struct field_value_data));
2122     if (data->fields)
2123     {
2124         data->fields[data->cFields].create = create;
2125         data->fields[data->cFields].detailed_value = NULL;
2126         data->fields[data->cFields].param = param;
2127         data->cFields++;
2128     }
2129 }
2130
2131 static void add_field_and_value_to_list(HWND hwnd, struct detail_data *data,
2132  LPWSTR field, LPWSTR value, create_detailed_value_func create, void *param)
2133 {
2134     LVITEMW item;
2135     int iItem = SendMessageW(hwnd, LVM_GETITEMCOUNT, 0, 0);
2136
2137     item.mask = LVIF_TEXT | LVIF_PARAM;
2138     item.iItem = iItem;
2139     item.iSubItem = 0;
2140     item.pszText = field;
2141     item.lParam = (LPARAM)data;
2142     SendMessageW(hwnd, LVM_INSERTITEMW, 0, (LPARAM)&item);
2143     if (value)
2144     {
2145         item.pszText = value;
2146         item.iSubItem = 1;
2147         SendMessageW(hwnd, LVM_SETITEMTEXTW, iItem, (LPARAM)&item);
2148     }
2149     add_field_value_data(data, create, param);
2150 }
2151
2152 static void add_string_id_and_value_to_list(HWND hwnd, struct detail_data *data,
2153  int id, LPWSTR value, create_detailed_value_func create, void *param)
2154 {
2155     WCHAR buf[MAX_STRING_LEN];
2156
2157     LoadStringW(hInstance, id, buf, sizeof(buf) / sizeof(buf[0]));
2158     add_field_and_value_to_list(hwnd, data, buf, value, create, param);
2159 }
2160
2161 struct v1_field
2162 {
2163     int id;
2164     field_format_func format;
2165     create_detailed_value_func create_detailed_value;
2166 };
2167
2168 static void add_v1_field(HWND hwnd, struct detail_data *data,
2169  const struct v1_field *field)
2170 {
2171     WCHAR *val = field->format(data->pCertViewInfo->pCertContext);
2172
2173     if (val)
2174     {
2175         add_string_id_and_value_to_list(hwnd, data, field->id, val,
2176          field->create_detailed_value, NULL);
2177         HeapFree(GetProcessHeap(), 0, val);
2178     }
2179 }
2180
2181 static const struct v1_field v1_fields[] = {
2182  { IDS_FIELD_VERSION, field_format_version, NULL },
2183  { IDS_FIELD_SERIAL_NUMBER, field_format_serial_number, NULL },
2184  { IDS_FIELD_ISSUER, field_format_issuer, field_format_detailed_issuer },
2185  { IDS_FIELD_VALID_FROM, field_format_from_date, NULL },
2186  { IDS_FIELD_VALID_TO, field_format_to_date, NULL },
2187  { IDS_FIELD_SUBJECT, field_format_subject, field_format_detailed_subject },
2188  { IDS_FIELD_PUBLIC_KEY, field_format_public_key,
2189    field_format_detailed_public_key }
2190 };
2191
2192 static void add_v1_fields(HWND hwnd, struct detail_data *data)
2193 {
2194     int i;
2195     PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
2196
2197     /* The last item in v1_fields is the public key, which is not in the loop
2198      * because it's a special case.
2199      */
2200     for (i = 0; i < sizeof(v1_fields) / sizeof(v1_fields[0]) - 1; i++)
2201         add_v1_field(hwnd, data, &v1_fields[i]);
2202     if (cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData)
2203         add_v1_field(hwnd, data, &v1_fields[i]);
2204 }
2205
2206 static WCHAR *crypt_format_extension(PCERT_EXTENSION ext, DWORD formatStrType)
2207 {
2208     WCHAR *str = NULL;
2209     DWORD size;
2210
2211     if (CryptFormatObject(X509_ASN_ENCODING, 0, formatStrType, NULL,
2212      ext->pszObjId, ext->Value.pbData, ext->Value.cbData, NULL, &size))
2213     {
2214         str = HeapAlloc(GetProcessHeap(), 0, size);
2215         CryptFormatObject(X509_ASN_ENCODING, 0, formatStrType, NULL,
2216          ext->pszObjId, ext->Value.pbData, ext->Value.cbData, str, &size);
2217     }
2218     return str;
2219 }
2220
2221 static WCHAR *field_format_extension_hex_with_ascii(PCERT_EXTENSION ext)
2222 {
2223     WCHAR *str = NULL;
2224
2225     if (ext->Value.cbData)
2226     {
2227         /* The output is formatted as:
2228          * <hex bytes>  <ascii bytes>\n
2229          * where <hex bytes> is a string of up to 8 bytes, output as %02x,
2230          * and <ascii bytes> is the ASCII equivalent of each byte, or '.' if
2231          * the byte is not printable.
2232          * So, for example, the extension value consisting of the following
2233          * bytes:
2234          *   0x30,0x14,0x31,0x12,0x30,0x10,0x06,0x03,0x55,0x04,0x03,
2235          *   0x13,0x09,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67
2236          * is output as:
2237          *   30 14 31 12 30 10 06 03  0.1.0...
2238          *   55 04 03 13 09 4a 75 61  U....Jua
2239          *   6e 20 4c 61 6e 67        n Lang
2240          * The allocation size therefore requires:
2241          * - 4 characters per character in an 8-byte line
2242          *   (2 for the hex format, one for the space, one for the ASCII value)
2243          * - 3 more characters per 8-byte line (two spaces and a newline)
2244          * - 1 character for the terminating nul
2245          * FIXME: should use a fixed-width font for this
2246          */
2247         DWORD lines = (ext->Value.cbData + 7) / 8;
2248
2249         str = HeapAlloc(GetProcessHeap(), 0,
2250          (lines * 8 * 4 + lines * 3 + 1) * sizeof(WCHAR));
2251         if (str)
2252         {
2253             static const WCHAR fmt[] = { '%','0','2','x',' ',0 };
2254             DWORD i, j;
2255             WCHAR *ptr;
2256
2257             for (i = 0, ptr = str; i < ext->Value.cbData; i += 8)
2258             {
2259                 /* Output as hex bytes first */
2260                 for (j = i; j < min(i + 8, ext->Value.cbData); j++, ptr += 3)
2261                     sprintfW(ptr, fmt, ext->Value.pbData[j]);
2262                 /* Pad the hex output with spaces for alignment */
2263                 if (j == ext->Value.cbData && j % 8)
2264                 {
2265                     static const WCHAR pad[] = { ' ',' ',' ' };
2266
2267                     for (; j % 8; j++, ptr += sizeof(pad) / sizeof(pad[0]))
2268                         memcpy(ptr, pad, sizeof(pad));
2269                 }
2270                 /* The last sprintfW included a space, so just insert one
2271                  * more space between the hex bytes and the ASCII output
2272                  */
2273                 *ptr++ = ' ';
2274                 /* Output as ASCII bytes */
2275                 for (j = i; j < min(i + 8, ext->Value.cbData); j++, ptr++)
2276                 {
2277                     if (isprintW(ext->Value.pbData[j]) &&
2278                      !isspaceW(ext->Value.pbData[j]))
2279                         *ptr = ext->Value.pbData[j];
2280                     else
2281                         *ptr = '.';
2282                 }
2283                 *ptr++ = '\n';
2284             }
2285             *ptr++ = '\0';
2286         }
2287     }
2288     return str;
2289 }
2290
2291 static WCHAR *field_format_detailed_extension(PCCERT_CONTEXT cert, void *param)
2292 {
2293     PCERT_EXTENSION ext = param;
2294     LPWSTR str = crypt_format_extension(ext,
2295      CRYPT_FORMAT_STR_MULTI_LINE | CRYPT_FORMAT_STR_NO_HEX);
2296
2297     if (!str)
2298         str = field_format_extension_hex_with_ascii(ext);
2299     return str;
2300 }
2301
2302 static void add_cert_extension_detail(HWND hwnd, struct detail_data *data,
2303  PCERT_EXTENSION ext)
2304 {
2305     PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
2306      ext->pszObjId, 0);
2307     LPWSTR val = crypt_format_extension(ext, 0);
2308
2309     if (oidInfo)
2310         add_field_and_value_to_list(hwnd, data, (LPWSTR)oidInfo->pwszName,
2311          val, field_format_detailed_extension, ext);
2312     else
2313     {
2314         DWORD len = strlen(ext->pszObjId);
2315         LPWSTR oidW = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
2316
2317         if (oidW)
2318         {
2319             DWORD i;
2320
2321             for (i = 0; i <= len; i++)
2322                 oidW[i] = ext->pszObjId[i];
2323             add_field_and_value_to_list(hwnd, data, oidW, val,
2324              field_format_detailed_extension, ext);
2325             HeapFree(GetProcessHeap(), 0, oidW);
2326         }
2327     }
2328     HeapFree(GetProcessHeap(), 0, val);
2329 }
2330
2331 static void add_all_extensions(HWND hwnd, struct detail_data *data)
2332 {
2333     DWORD i;
2334     PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
2335
2336     for (i = 0; i < cert->pCertInfo->cExtension; i++)
2337         add_cert_extension_detail(hwnd, data, &cert->pCertInfo->rgExtension[i]);
2338 }
2339
2340 static void add_critical_extensions(HWND hwnd, struct detail_data *data)
2341 {
2342     DWORD i;
2343     PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
2344
2345     for (i = 0; i < cert->pCertInfo->cExtension; i++)
2346         if (cert->pCertInfo->rgExtension[i].fCritical)
2347             add_cert_extension_detail(hwnd, data,
2348              &cert->pCertInfo->rgExtension[i]);
2349 }
2350
2351 typedef WCHAR * (*prop_to_value_func)(void *pb, DWORD cb);
2352
2353 struct prop_id_to_string_id
2354 {
2355     DWORD prop;
2356     int id;
2357     BOOL prop_is_string;
2358     prop_to_value_func prop_to_value;
2359 };
2360
2361 static WCHAR *format_enhanced_key_usage_value(void *pb, DWORD cb)
2362 {
2363     CERT_EXTENSION ext;
2364
2365     ext.pszObjId = (LPSTR)X509_ENHANCED_KEY_USAGE;
2366     ext.fCritical = FALSE;
2367     ext.Value.pbData = pb;
2368     ext.Value.cbData = cb;
2369     return crypt_format_extension(&ext, 0);
2370 }
2371
2372 /* Logically the access state should also be checked, and IDC_EDITPROPERTIES
2373  * disabled for read-only certificates, but native doesn't appear to do that.
2374  */
2375 static const struct prop_id_to_string_id prop_id_map[] = {
2376  { CERT_HASH_PROP_ID, IDS_PROP_HASH, FALSE, format_hex_string },
2377  { CERT_FRIENDLY_NAME_PROP_ID, IDS_PROP_FRIENDLY_NAME, TRUE, NULL },
2378  { CERT_DESCRIPTION_PROP_ID, IDS_PROP_DESCRIPTION, TRUE, NULL },
2379  { CERT_ENHKEY_USAGE_PROP_ID, IDS_PROP_ENHKEY_USAGE, FALSE,
2380    format_enhanced_key_usage_value },
2381 };
2382
2383 static void add_properties(HWND hwnd, struct detail_data *data)
2384 {
2385     DWORD i;
2386     PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
2387
2388     for (i = 0; i < sizeof(prop_id_map) / sizeof(prop_id_map[0]); i++)
2389     {
2390         DWORD cb;
2391
2392         if (CertGetCertificateContextProperty(cert, prop_id_map[i].prop, NULL,
2393          &cb))
2394         {
2395             BYTE *pb;
2396             WCHAR *val = NULL;
2397
2398             /* FIXME: MS adds a separate value for the signature hash
2399              * algorithm.
2400              */
2401             pb = HeapAlloc(GetProcessHeap(), 0, cb);
2402             if (pb)
2403             {
2404                 if (CertGetCertificateContextProperty(cert,
2405                  prop_id_map[i].prop, pb, &cb))
2406                 {
2407                     if (prop_id_map[i].prop_is_string)
2408                     {
2409                         val = (LPWSTR)pb;
2410                         /* Don't double-free pb */
2411                         pb = NULL;
2412                     }
2413                     else
2414                         val = prop_id_map[i].prop_to_value(pb, cb);
2415                 }
2416                 HeapFree(GetProcessHeap(), 0, pb);
2417             }
2418             add_string_id_and_value_to_list(hwnd, data, prop_id_map[i].id, val,
2419              NULL, NULL);
2420         }
2421     }
2422 }
2423
2424 static void add_all_fields(HWND hwnd, struct detail_data *data)
2425 {
2426     add_v1_fields(hwnd, data);
2427     add_all_extensions(hwnd, data);
2428     add_properties(hwnd, data);
2429 }
2430
2431 struct selection_list_item
2432 {
2433     int id;
2434     add_fields_func add;
2435 };
2436
2437 const struct selection_list_item listItems[] = {
2438  { IDS_FIELDS_ALL, add_all_fields },
2439  { IDS_FIELDS_V1, add_v1_fields },
2440  { IDS_FIELDS_EXTENSIONS, add_all_extensions },
2441  { IDS_FIELDS_CRITICAL_EXTENSIONS, add_critical_extensions },
2442  { IDS_FIELDS_PROPERTIES, add_properties },
2443 };
2444
2445 static void create_show_list(HWND hwnd, struct detail_data *data)
2446 {
2447     HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
2448     WCHAR buf[MAX_STRING_LEN];
2449     int i;
2450
2451     for (i = 0; i < sizeof(listItems) / sizeof(listItems[0]); i++)
2452     {
2453         int index;
2454
2455         LoadStringW(hInstance, listItems[i].id, buf,
2456          sizeof(buf) / sizeof(buf[0]));
2457         index = SendMessageW(cb, CB_INSERTSTRING, -1, (LPARAM)buf);
2458         SendMessageW(cb, CB_SETITEMDATA, index, (LPARAM)data);
2459     }
2460     SendMessageW(cb, CB_SETCURSEL, 0, 0);
2461 }
2462
2463 static void create_listview_columns(HWND hwnd)
2464 {
2465     HWND lv = GetDlgItem(hwnd, IDC_DETAIL_LIST);
2466     RECT rc;
2467     WCHAR buf[MAX_STRING_LEN];
2468     LVCOLUMNW column;
2469
2470     SendMessageW(lv, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
2471     GetWindowRect(lv, &rc);
2472     LoadStringW(hInstance, IDS_FIELD, buf, sizeof(buf) / sizeof(buf[0]));
2473     column.mask = LVCF_WIDTH | LVCF_TEXT;
2474     column.cx = (rc.right - rc.left) / 2 - 2;
2475     column.pszText = buf;
2476     SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
2477     LoadStringW(hInstance, IDS_VALUE, buf, sizeof(buf) / sizeof(buf[0]));
2478     SendMessageW(lv, LVM_INSERTCOLUMNW, 1, (LPARAM)&column);
2479 }
2480
2481 static void set_fields_selection(HWND hwnd, struct detail_data *data, int sel)
2482 {
2483     HWND list = GetDlgItem(hwnd, IDC_DETAIL_LIST);
2484
2485     if (sel >= 0 && sel < sizeof(listItems) / sizeof(listItems[0]))
2486     {
2487         SendMessageW(list, LVM_DELETEALLITEMS, 0, 0);
2488         listItems[sel].add(list, data);
2489     }
2490 }
2491
2492 static void create_cert_details_list(HWND hwnd, struct detail_data *data)
2493 {
2494     create_show_list(hwnd, data);
2495     create_listview_columns(hwnd);
2496     set_fields_selection(hwnd, data, 0);
2497 }
2498
2499 static void add_purpose(HWND hwnd, LPCSTR oid)
2500 {
2501     HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
2502     PCRYPT_OID_INFO info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2503      sizeof(CRYPT_OID_INFO));
2504
2505     if (info)
2506     {
2507         char *oidCopy = HeapAlloc(GetProcessHeap(), 0, strlen(oid) + 1);
2508
2509         if (oidCopy)
2510         {
2511             LVITEMA item;
2512
2513             strcpy(oidCopy, oid);
2514             info->cbSize = sizeof(CRYPT_OID_INFO);
2515             info->pszOID = oidCopy;
2516             item.mask = LVIF_TEXT | LVIF_STATE | LVIF_PARAM;
2517             item.state = INDEXTOSTATEIMAGEMASK(CheckBitmapIndexChecked);
2518             item.stateMask = LVIS_STATEIMAGEMASK;
2519             item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
2520             item.iSubItem = 0;
2521             item.lParam = (LPARAM)info;
2522             item.pszText = oidCopy;
2523             SendMessageA(lv, LVM_INSERTITEMA, 0, (LPARAM)&item);
2524         }
2525         else
2526             HeapFree(GetProcessHeap(), 0, info);
2527     }
2528 }
2529
2530 static BOOL is_valid_oid(LPCSTR oid)
2531 {
2532     BOOL ret;
2533
2534     if (oid[0] != '0' && oid[0] != '1' && oid[0] != '2')
2535         ret = FALSE;
2536     else if (oid[1] != '.')
2537         ret = FALSE;
2538     else if (!oid[2])
2539         ret = FALSE;
2540     else
2541     {
2542         const char *ptr;
2543         BOOL expectNum = TRUE;
2544
2545         for (ptr = oid + 2, ret = TRUE; ret && *ptr; ptr++)
2546         {
2547             if (expectNum)
2548             {
2549                 if (!isdigit(*ptr))
2550                     ret = FALSE;
2551                 else if (*(ptr + 1) == '.')
2552                     expectNum = FALSE;
2553             }
2554             else
2555             {
2556                 if (*ptr != '.')
2557                     ret = FALSE;
2558                 else if (!(*(ptr + 1)))
2559                     ret = FALSE;
2560                 else
2561                     expectNum = TRUE;
2562             }
2563         }
2564     }
2565     return ret;
2566 }
2567
2568 static BOOL is_oid_in_list(HWND hwnd, LPCSTR oid)
2569 {
2570     return find_oid_in_list(GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES), oid)
2571      != -1;
2572 }
2573
2574 #define MAX_PURPOSE 255
2575
2576 static LRESULT CALLBACK add_purpose_dlg_proc(HWND hwnd, UINT msg,
2577  WPARAM wp, LPARAM lp)
2578 {
2579     LRESULT ret = 0;
2580     char buf[MAX_PURPOSE + 1];
2581
2582     switch (msg)
2583     {
2584     case WM_INITDIALOG:
2585         SendMessageW(GetDlgItem(hwnd, IDC_NEW_PURPOSE), EM_SETLIMITTEXT,
2586          MAX_PURPOSE, 0);
2587         ShowScrollBar(GetDlgItem(hwnd, IDC_NEW_PURPOSE), SB_VERT, FALSE);
2588         SetWindowLongPtrW(hwnd, DWLP_USER, lp);
2589         break;
2590     case WM_COMMAND:
2591         switch (HIWORD(wp))
2592         {
2593         case EN_CHANGE:
2594             if (LOWORD(wp) == IDC_NEW_PURPOSE)
2595             {
2596                 /* Show/hide scroll bar on description depending on how much
2597                  * text it has.
2598                  */
2599                 HWND description = GetDlgItem(hwnd, IDC_NEW_PURPOSE);
2600                 int lines = SendMessageW(description, EM_GETLINECOUNT, 0, 0);
2601
2602                 ShowScrollBar(description, SB_VERT, lines > 1);
2603             }
2604             break;
2605         case BN_CLICKED:
2606             switch (LOWORD(wp))
2607             {
2608             case IDOK:
2609                 SendMessageA(GetDlgItem(hwnd, IDC_NEW_PURPOSE), WM_GETTEXT,
2610                  sizeof(buf) / sizeof(buf[0]), (LPARAM)buf);
2611                 if (!buf[0])
2612                 {
2613                     /* An empty purpose is the same as cancelling */
2614                     EndDialog(hwnd, IDCANCEL);
2615                     ret = TRUE;
2616                 }
2617                 else if (!is_valid_oid(buf))
2618                 {
2619                     WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
2620
2621                     LoadStringW(hInstance, IDS_CERTIFICATE_PURPOSE_ERROR, error,
2622                      sizeof(error) / sizeof(error[0]));
2623                     LoadStringW(hInstance, IDS_CERTIFICATE_PROPERTIES, title,
2624                      sizeof(title) / sizeof(title[0]));
2625                     MessageBoxW(hwnd, error, title, MB_ICONERROR | MB_OK);
2626                 }
2627                 else if (is_oid_in_list(
2628                  (HWND)GetWindowLongPtrW(hwnd, DWLP_USER), buf))
2629                 {
2630                     WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
2631
2632                     LoadStringW(hInstance, IDS_CERTIFICATE_PURPOSE_EXISTS,
2633                      error, sizeof(error) / sizeof(error[0]));
2634                     LoadStringW(hInstance, IDS_CERTIFICATE_PROPERTIES, title,
2635                      sizeof(title) / sizeof(title[0]));
2636                     MessageBoxW(hwnd, error, title, MB_ICONEXCLAMATION | MB_OK);
2637                 }
2638                 else
2639                 {
2640                     HWND parent = (HWND)GetWindowLongPtrW(hwnd, DWLP_USER);
2641
2642                     add_purpose(parent, buf);
2643                     EndDialog(hwnd, wp);
2644                     ret = TRUE;
2645                 }
2646                 break;
2647             case IDCANCEL:
2648                 EndDialog(hwnd, wp);
2649                 ret = TRUE;
2650                 break;
2651             }
2652             break;
2653         }
2654         break;
2655     }
2656     return ret;
2657 }
2658
2659 static WCHAR *get_cert_property_as_string(PCCERT_CONTEXT cert, DWORD prop)
2660 {
2661     WCHAR *name = NULL;
2662     DWORD cb;
2663
2664     if (CertGetCertificateContextProperty(cert, prop, NULL, &cb))
2665     {
2666         name = HeapAlloc(GetProcessHeap(), 0, cb);
2667         if (name)
2668         {
2669             if (!CertGetCertificateContextProperty(cert, prop, (LPBYTE)name,
2670              &cb))
2671             {
2672                 HeapFree(GetProcessHeap(), 0, name);
2673                 name = NULL;
2674             }
2675         }
2676     }
2677     return name;
2678 }
2679
2680 static void redraw_states(HWND list, BOOL enabled)
2681 {
2682     int items = SendMessageW(list, LVM_GETITEMCOUNT, 0, 0), i;
2683
2684     for (i = 0; i < items; i++)
2685     {
2686         BOOL change = FALSE;
2687         int state;
2688
2689         state = SendMessageW(list, LVM_GETITEMSTATE, i, LVIS_STATEIMAGEMASK);
2690         /* This reverses the INDEXTOSTATEIMAGEMASK shift.  There doesn't appear
2691          * to be a handy macro for it.
2692          */
2693         state >>= 12;
2694         if (enabled)
2695         {
2696             if (state == CheckBitmapIndexDisabledChecked)
2697             {
2698                 state = CheckBitmapIndexChecked;
2699                 change = TRUE;
2700             }
2701             if (state == CheckBitmapIndexDisabledUnchecked)
2702             {
2703                 state = CheckBitmapIndexUnchecked;
2704                 change = TRUE;
2705             }
2706         }
2707         else
2708         {
2709             if (state == CheckBitmapIndexChecked)
2710             {
2711                 state = CheckBitmapIndexDisabledChecked;
2712                 change = TRUE;
2713             }
2714             if (state == CheckBitmapIndexUnchecked)
2715             {
2716                 state = CheckBitmapIndexDisabledUnchecked;
2717                 change = TRUE;
2718             }
2719         }
2720         if (change)
2721         {
2722             LVITEMW item;
2723
2724             item.state = INDEXTOSTATEIMAGEMASK(state);
2725             item.stateMask = LVIS_STATEIMAGEMASK;
2726             SendMessageW(list, LVM_SETITEMSTATE, i, (LPARAM)&item);
2727         }
2728     }
2729 }
2730
2731 typedef enum {
2732     PurposeEnableAll = 0,
2733     PurposeDisableAll,
2734     PurposeEnableSelected
2735 } PurposeSelection;
2736
2737 static void select_purposes(HWND hwnd, PurposeSelection selection)
2738 {
2739     HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
2740
2741     switch (selection)
2742     {
2743     case PurposeEnableAll:
2744     case PurposeDisableAll:
2745         EnableWindow(lv, FALSE);
2746         redraw_states(lv, FALSE);
2747         EnableWindow(GetDlgItem(hwnd, IDC_ADD_PURPOSE), FALSE);
2748         break;
2749     case PurposeEnableSelected:
2750         EnableWindow(lv, TRUE);
2751         redraw_states(lv, TRUE);
2752         EnableWindow(GetDlgItem(hwnd, IDC_ADD_PURPOSE), TRUE);
2753     }
2754 }
2755
2756 struct edit_cert_data
2757 {
2758     PCCERT_CONTEXT cert;
2759     BOOL *pfPropertiesChanged;
2760     HIMAGELIST imageList;
2761 };
2762
2763 static void show_cert_usages(HWND hwnd, struct edit_cert_data *data)
2764 {
2765     PCCERT_CONTEXT cert = data->cert;
2766     HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
2767     PCERT_ENHKEY_USAGE usage;
2768     DWORD size;
2769     RECT rc;
2770     LVCOLUMNW column;
2771     PurposeSelection purposeSelection;
2772
2773     GetWindowRect(lv, &rc);
2774     column.mask = LVCF_WIDTH;
2775     column.cx = rc.right - rc.left;
2776     SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
2777     SendMessageW(lv, LVM_SETIMAGELIST, LVSIL_STATE, (LPARAM)data->imageList);
2778
2779     /* Get enhanced key usage.  Have to check for a property and an extension
2780      * separately, because CertGetEnhancedKeyUsage will succeed and return an
2781      * empty usage if neither is set.  Unfortunately an empty usage implies
2782      * no usage is allowed, so we have to distinguish between the two cases.
2783      */
2784     if (CertGetEnhancedKeyUsage(cert, CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG,
2785      NULL, &size))
2786     {
2787         usage = HeapAlloc(GetProcessHeap(), 0, size);
2788         if (!CertGetEnhancedKeyUsage(cert,
2789          CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG, usage, &size))
2790         {
2791             HeapFree(GetProcessHeap(), 0, usage);
2792             usage = NULL;
2793         }
2794         else if (usage->cUsageIdentifier)
2795             purposeSelection = PurposeEnableSelected;
2796         else
2797             purposeSelection = PurposeDisableAll;
2798     }
2799     else if (CertGetEnhancedKeyUsage(cert, CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG,
2800      NULL, &size))
2801     {
2802         usage = HeapAlloc(GetProcessHeap(), 0, size);
2803         if (!CertGetEnhancedKeyUsage(cert,
2804          CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG, usage, &size))
2805         {
2806             HeapFree(GetProcessHeap(), 0, usage);
2807             usage = NULL;
2808         }
2809         else if (usage->cUsageIdentifier)
2810             purposeSelection = PurposeEnableAll;
2811         else
2812             purposeSelection = PurposeDisableAll;
2813     }
2814     else
2815     {
2816         purposeSelection = PurposeEnableAll;
2817         usage = NULL;
2818     }
2819     if (usage)
2820     {
2821         DWORD i;
2822
2823         for (i = 0; i < usage->cUsageIdentifier; i++)
2824         {
2825             PCCRYPT_OID_INFO info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
2826              usage->rgpszUsageIdentifier[i], CRYPT_ENHKEY_USAGE_OID_GROUP_ID);
2827
2828             if (info)
2829                 add_known_usage(lv, info, CheckBitmapIndexDisabledChecked);
2830             else
2831                 add_purpose(hwnd, usage->rgpszUsageIdentifier[i]);
2832         }
2833         HeapFree(GetProcessHeap(), 0, usage);
2834     }
2835     else
2836         add_known_usages_to_list(lv, CheckBitmapIndexDisabledChecked);
2837     select_purposes(hwnd, purposeSelection);
2838     SendMessageW(GetDlgItem(hwnd, IDC_ENABLE_ALL_PURPOSES + purposeSelection),
2839      BM_CLICK, 0, 0);
2840 }
2841
2842 static void set_general_cert_properties(HWND hwnd, struct edit_cert_data *data)
2843 {
2844     PCCERT_CONTEXT cert = data->cert;
2845     WCHAR *str;
2846
2847     if ((str = get_cert_property_as_string(cert, CERT_FRIENDLY_NAME_PROP_ID)))
2848     {
2849         SendMessageW(GetDlgItem(hwnd, IDC_FRIENDLY_NAME), WM_SETTEXT, 0,
2850          (LPARAM)str);
2851         HeapFree(GetProcessHeap(), 0, str);
2852     }
2853     if ((str = get_cert_property_as_string(cert, CERT_DESCRIPTION_PROP_ID)))
2854     {
2855         SendMessageW(GetDlgItem(hwnd, IDC_DESCRIPTION), WM_SETTEXT, 0,
2856          (LPARAM)str);
2857         HeapFree(GetProcessHeap(), 0, str);
2858     }
2859     show_cert_usages(hwnd, data);
2860 }
2861
2862 static void set_cert_string_property(PCCERT_CONTEXT cert, DWORD prop,
2863  LPWSTR str)
2864 {
2865     if (str && strlenW(str))
2866     {
2867         CRYPT_DATA_BLOB blob;
2868
2869         blob.pbData = (BYTE *)str;
2870         blob.cbData = (strlenW(str) + 1) * sizeof(WCHAR);
2871         CertSetCertificateContextProperty(cert, prop, 0, &blob);
2872     }
2873     else
2874         CertSetCertificateContextProperty(cert, prop, 0, NULL);
2875 }
2876
2877 #define WM_REFRESH_VIEW WM_USER + 0
2878
2879 static BOOL CALLBACK refresh_propsheet_pages(HWND hwnd, LPARAM lParam)
2880 {
2881     if ((GetClassLongW(hwnd, GCW_ATOM) == WC_DIALOG))
2882         SendMessageW(hwnd, WM_REFRESH_VIEW, 0, 0);
2883     return TRUE;
2884 }
2885
2886 #define MAX_FRIENDLY_NAME 40
2887 #define MAX_DESCRIPTION 255
2888
2889 static void apply_general_changes(HWND hwnd)
2890 {
2891     WCHAR buf[MAX_DESCRIPTION + 1];
2892     struct edit_cert_data *data =
2893      (struct edit_cert_data *)GetWindowLongPtrW(hwnd, DWLP_USER);
2894
2895     SendMessageW(GetDlgItem(hwnd, IDC_FRIENDLY_NAME), WM_GETTEXT,
2896      sizeof(buf) / sizeof(buf[0]), (LPARAM)buf);
2897     set_cert_string_property(data->cert, CERT_FRIENDLY_NAME_PROP_ID, buf);
2898     SendMessageW(GetDlgItem(hwnd, IDC_DESCRIPTION), WM_GETTEXT,
2899      sizeof(buf) / sizeof(buf[0]), (LPARAM)buf);
2900     set_cert_string_property(data->cert, CERT_DESCRIPTION_PROP_ID, buf);
2901     if (IsDlgButtonChecked(hwnd, IDC_ENABLE_ALL_PURPOSES))
2902     {
2903         /* Setting a NULL usage removes the enhanced key usage property. */
2904         CertSetEnhancedKeyUsage(data->cert, NULL);
2905     }
2906     else if (IsDlgButtonChecked(hwnd, IDC_DISABLE_ALL_PURPOSES))
2907     {
2908         CERT_ENHKEY_USAGE usage = { 0, NULL };
2909
2910         CertSetEnhancedKeyUsage(data->cert, &usage);
2911     }
2912     else if (IsDlgButtonChecked(hwnd, IDC_ENABLE_SELECTED_PURPOSES))
2913     {
2914         HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
2915         CERT_ENHKEY_USAGE usage = { 0, NULL };
2916         int purposes = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0), i;
2917         LVITEMW item;
2918
2919         item.mask = LVIF_STATE | LVIF_PARAM;
2920         item.iSubItem = 0;
2921         item.stateMask = LVIS_STATEIMAGEMASK;
2922         for (i = 0; i < purposes; i++)
2923         {
2924             item.iItem = i;
2925             if (SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item))
2926             {
2927                 int state = item.state >> 12;
2928
2929                 if (state == CheckBitmapIndexChecked)
2930                 {
2931                     CRYPT_OID_INFO *info = (CRYPT_OID_INFO *)item.lParam;
2932
2933                     if (usage.cUsageIdentifier)
2934                         usage.rgpszUsageIdentifier =
2935                          HeapReAlloc(GetProcessHeap(), 0,
2936                          usage.rgpszUsageIdentifier,
2937                          (usage.cUsageIdentifier + 1) * sizeof(LPSTR));
2938                     else
2939                         usage.rgpszUsageIdentifier =
2940                          HeapAlloc(GetProcessHeap(), 0, sizeof(LPSTR));
2941                     if (usage.rgpszUsageIdentifier)
2942                         usage.rgpszUsageIdentifier[usage.cUsageIdentifier++] =
2943                          (LPSTR)info->pszOID;
2944                 }
2945             }
2946         }
2947         CertSetEnhancedKeyUsage(data->cert, &usage);
2948         HeapFree(GetProcessHeap(), 0, usage.rgpszUsageIdentifier);
2949     }
2950     EnumChildWindows(GetParent(GetParent(hwnd)), refresh_propsheet_pages, 0);
2951     if (data->pfPropertiesChanged)
2952         *data->pfPropertiesChanged = TRUE;
2953 }
2954
2955 static LRESULT CALLBACK cert_properties_general_dlg_proc(HWND hwnd, UINT msg,
2956  WPARAM wp, LPARAM lp)
2957 {
2958     PROPSHEETPAGEW *page;
2959
2960     TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
2961
2962     switch (msg)
2963     {
2964     case WM_INITDIALOG:
2965     {
2966         HWND description = GetDlgItem(hwnd, IDC_DESCRIPTION);
2967         struct detail_data *detailData;
2968         struct edit_cert_data *editData;
2969
2970         page = (PROPSHEETPAGEW *)lp;
2971         detailData = (struct detail_data *)page->lParam;
2972         SendMessageW(GetDlgItem(hwnd, IDC_FRIENDLY_NAME), EM_SETLIMITTEXT,
2973          MAX_FRIENDLY_NAME, 0);
2974         SendMessageW(description, EM_SETLIMITTEXT, MAX_DESCRIPTION, 0);
2975         ShowScrollBar(description, SB_VERT, FALSE);
2976         editData = HeapAlloc(GetProcessHeap(), 0,
2977          sizeof(struct edit_cert_data));
2978         if (editData)
2979         {
2980             editData->imageList = ImageList_Create(16, 16,
2981              ILC_COLOR4 | ILC_MASK, 4, 0);
2982             if (editData->imageList)
2983             {
2984                 HBITMAP bmp;
2985                 COLORREF backColor = RGB(255, 0, 255);
2986
2987                 bmp = LoadBitmapW(hInstance, MAKEINTRESOURCEW(IDB_CHECKS));
2988                 ImageList_AddMasked(editData->imageList, bmp, backColor);
2989                 DeleteObject(bmp);
2990                 ImageList_SetBkColor(editData->imageList, CLR_NONE);
2991             }
2992             editData->cert = detailData->pCertViewInfo->pCertContext;
2993             editData->pfPropertiesChanged = detailData->pfPropertiesChanged;
2994             SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)editData);
2995             set_general_cert_properties(hwnd, editData);
2996         }
2997         break;
2998     }
2999     case WM_NOTIFY:
3000     {
3001         NMHDR *hdr = (NMHDR *)lp;
3002         NMITEMACTIVATE *nm;
3003
3004         switch (hdr->code)
3005         {
3006         case NM_CLICK:
3007             nm = (NMITEMACTIVATE *)lp;
3008             toggle_usage(hwnd, nm->iItem);
3009             SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
3010             break;
3011         case PSN_APPLY:
3012             apply_general_changes(hwnd);
3013             break;
3014         }
3015         break;
3016     }
3017     case WM_COMMAND:
3018         switch (HIWORD(wp))
3019         {
3020         case EN_CHANGE:
3021             SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
3022             if (LOWORD(wp) == IDC_DESCRIPTION)
3023             {
3024                 /* Show/hide scroll bar on description depending on how much
3025                  * text it has.
3026                  */
3027                 HWND description = GetDlgItem(hwnd, IDC_DESCRIPTION);
3028                 int lines = SendMessageW(description, EM_GETLINECOUNT, 0, 0);
3029
3030                 ShowScrollBar(description, SB_VERT, lines > 1);
3031             }
3032             break;
3033         case BN_CLICKED:
3034             switch (LOWORD(wp))
3035             {
3036             case IDC_ADD_PURPOSE:
3037                 if (DialogBoxParamW(hInstance,
3038                  MAKEINTRESOURCEW(IDD_ADD_CERT_PURPOSE), hwnd,
3039                  add_purpose_dlg_proc, (LPARAM)hwnd) == IDOK)
3040                     SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
3041                 break;
3042             case IDC_ENABLE_ALL_PURPOSES:
3043             case IDC_DISABLE_ALL_PURPOSES:
3044             case IDC_ENABLE_SELECTED_PURPOSES:
3045                 SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
3046                 select_purposes(hwnd, LOWORD(wp) - IDC_ENABLE_ALL_PURPOSES);
3047                 break;
3048             }
3049             break;
3050         }
3051         break;
3052     }
3053     return 0;
3054 }
3055
3056 static UINT CALLBACK cert_properties_general_callback(HWND hwnd, UINT msg,
3057  PROPSHEETPAGEW *page)
3058 {
3059     HWND lv;
3060     int cItem, i;
3061     struct edit_cert_data *data;
3062
3063     switch (msg)
3064     {
3065     case PSPCB_RELEASE:
3066         lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
3067         cItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
3068         for (i = 0; i < cItem; i++)
3069         {
3070             LVITEMW item;
3071
3072             item.mask = LVIF_PARAM;
3073             item.iItem = i;
3074             item.iSubItem = 0;
3075             if (SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item) && item.lParam)
3076             {
3077                 PCRYPT_OID_INFO info = (PCRYPT_OID_INFO)item.lParam;
3078
3079                 if (info->cbSize == sizeof(CRYPT_OID_INFO) && !info->dwGroupId)
3080                 {
3081                     HeapFree(GetProcessHeap(), 0, (LPSTR)info->pszOID);
3082                     HeapFree(GetProcessHeap(), 0, info);
3083                 }
3084             }
3085         }
3086         data = (struct edit_cert_data *)GetWindowLongPtrW(hwnd, DWLP_USER);
3087         if (data)
3088         {
3089             ImageList_Destroy(data->imageList);
3090             HeapFree(GetProcessHeap(), 0, data);
3091         }
3092         break;
3093     }
3094     return 1;
3095 }
3096
3097 static void show_edit_cert_properties_dialog(HWND parent,
3098  struct detail_data *data)
3099 {
3100     PROPSHEETHEADERW hdr;
3101     PROPSHEETPAGEW page; /* FIXME: need to add a cross-certificate page */
3102
3103     TRACE("(%p)\n", data);
3104
3105     memset(&page, 0, sizeof(PROPSHEETPAGEW));
3106     page.dwSize = sizeof(page);
3107     page.dwFlags = PSP_USECALLBACK;
3108     page.pfnCallback = cert_properties_general_callback;
3109     page.hInstance = hInstance;
3110     page.u.pszTemplate = MAKEINTRESOURCEW(IDD_CERT_PROPERTIES_GENERAL);
3111     page.pfnDlgProc = cert_properties_general_dlg_proc;
3112     page.lParam = (LPARAM)data;
3113
3114     memset(&hdr, 0, sizeof(hdr));
3115     hdr.dwSize = sizeof(hdr);
3116     hdr.hwndParent = parent;
3117     hdr.dwFlags = PSH_PROPSHEETPAGE;
3118     hdr.hInstance = hInstance;
3119     hdr.pszCaption = MAKEINTRESOURCEW(IDS_CERTIFICATE_PROPERTIES);
3120     hdr.u3.ppsp = &page;
3121     hdr.nPages = 1;
3122     PropertySheetW(&hdr);
3123 }
3124
3125 static void free_detail_fields(struct detail_data *data)
3126 {
3127     DWORD i;
3128
3129     for (i = 0; i < data->cFields; i++)
3130         HeapFree(GetProcessHeap(), 0, data->fields[i].detailed_value);
3131     HeapFree(GetProcessHeap(), 0, data->fields);
3132     data->fields = NULL;
3133     data->cFields = 0;
3134 }
3135
3136 static void refresh_details_view(HWND hwnd)
3137 {
3138     HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
3139     int curSel;
3140     struct detail_data *data;
3141
3142     curSel = SendMessageW(cb, CB_GETCURSEL, 0, 0);
3143     /* Actually, any index will do, since they all store the same data value */
3144     data = (struct detail_data *)SendMessageW(cb, CB_GETITEMDATA, curSel, 0);
3145     free_detail_fields(data);
3146     set_fields_selection(hwnd, data, curSel);
3147 }
3148
3149 static LRESULT CALLBACK detail_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
3150  LPARAM lp)
3151 {
3152     PROPSHEETPAGEW *page;
3153     struct detail_data *data;
3154
3155     TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
3156
3157     switch (msg)
3158     {
3159     case WM_INITDIALOG:
3160         page = (PROPSHEETPAGEW *)lp;
3161         data = (struct detail_data *)page->lParam;
3162         create_cert_details_list(hwnd, data);
3163         if (!(data->pCertViewInfo->dwFlags & CRYPTUI_ENABLE_EDITPROPERTIES))
3164             EnableWindow(GetDlgItem(hwnd, IDC_EDITPROPERTIES), FALSE);
3165         if (data->pCertViewInfo->dwFlags & CRYPTUI_DISABLE_EXPORT)
3166             EnableWindow(GetDlgItem(hwnd, IDC_EXPORT), FALSE);
3167         break;
3168     case WM_NOTIFY:
3169     {
3170         NMITEMACTIVATE *nm;
3171         HWND list = GetDlgItem(hwnd, IDC_DETAIL_LIST);
3172
3173         nm = (NMITEMACTIVATE*)lp;
3174         if (nm->hdr.hwndFrom == list && nm->uNewState & LVN_ITEMACTIVATE
3175          && nm->hdr.code == LVN_ITEMCHANGED)
3176         {
3177             data = (struct detail_data *)nm->lParam;
3178             if (nm->iItem >= 0 && data && nm->iItem < data->cFields)
3179             {
3180                 WCHAR buf[MAX_STRING_LEN], *val = NULL;
3181                 HWND valueCtl = GetDlgItem(hwnd, IDC_DETAIL_VALUE);
3182
3183                 if (data->fields[nm->iItem].create)
3184                     val = data->fields[nm->iItem].create(
3185                      data->pCertViewInfo->pCertContext,
3186                      data->fields[nm->iItem].param);
3187                 else
3188                 {
3189                     LVITEMW item;
3190                     int res;
3191
3192                     item.cchTextMax = sizeof(buf) / sizeof(buf[0]);
3193                     item.mask = LVIF_TEXT;
3194                     item.pszText = buf;
3195                     item.iItem = nm->iItem;
3196                     item.iSubItem = 1;
3197                     res = SendMessageW(list, LVM_GETITEMW, 0, (LPARAM)&item);
3198                     if (res)
3199                         val = buf;
3200                 }
3201                 /* Select all the text in the control, the next update will
3202                  * replace it
3203                  */
3204                 SendMessageW(valueCtl, EM_SETSEL, 0, -1);
3205                 add_unformatted_text_to_control(valueCtl, val,
3206                  val ? strlenW(val) : 0);
3207                 if (val != buf)
3208                     HeapFree(GetProcessHeap(), 0, val);
3209             }
3210         }
3211         break;
3212     }
3213     case WM_COMMAND:
3214         switch (wp)
3215         {
3216         case IDC_EXPORT:
3217             FIXME("call CryptUIWizExport\n");
3218             break;
3219         case IDC_EDITPROPERTIES:
3220         {
3221             HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
3222             int curSel;
3223
3224             curSel = SendMessageW(cb, CB_GETCURSEL, 0, 0);
3225             /* Actually, any index will do, since they all store the same
3226              * data value
3227              */
3228             data = (struct detail_data *)SendMessageW(cb, CB_GETITEMDATA,
3229              curSel, 0);
3230             show_edit_cert_properties_dialog(GetParent(hwnd), data);
3231             break;
3232         }
3233         case ((CBN_SELCHANGE << 16) | IDC_DETAIL_SELECT):
3234             refresh_details_view(hwnd);
3235             break;
3236         }
3237         break;
3238     case WM_REFRESH_VIEW:
3239         refresh_details_view(hwnd);
3240         break;
3241     }
3242     return 0;
3243 }
3244
3245 static UINT CALLBACK detail_callback(HWND hwnd, UINT msg,
3246  PROPSHEETPAGEW *page)
3247 {
3248     struct detail_data *data;
3249
3250     switch (msg)
3251     {
3252     case PSPCB_RELEASE:
3253         data = (struct detail_data *)page->lParam;
3254         free_detail_fields(data);
3255         HeapFree(GetProcessHeap(), 0, data);
3256         break;
3257     }
3258     return 0;
3259 }
3260
3261 static BOOL init_detail_page(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
3262  BOOL *pfPropertiesChanged, PROPSHEETPAGEW *page)
3263 {
3264     BOOL ret;
3265     struct detail_data *data = HeapAlloc(GetProcessHeap(), 0,
3266      sizeof(struct detail_data));
3267
3268     if (data)
3269     {
3270         data->pCertViewInfo = pCertViewInfo;
3271         data->pfPropertiesChanged = pfPropertiesChanged;
3272         data->cFields = 0;
3273         data->fields = NULL;
3274         memset(page, 0, sizeof(PROPSHEETPAGEW));
3275         page->dwSize = sizeof(PROPSHEETPAGEW);
3276         page->dwFlags = PSP_USECALLBACK;
3277         page->pfnCallback = detail_callback;
3278         page->hInstance = hInstance;
3279         page->u.pszTemplate = MAKEINTRESOURCEW(IDD_DETAIL);
3280         page->pfnDlgProc = detail_dlg_proc;
3281         page->lParam = (LPARAM)data;
3282         ret = TRUE;
3283     }
3284     else
3285         ret = FALSE;
3286     return ret;
3287 }
3288
3289 struct hierarchy_data
3290 {
3291     PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo;
3292     HIMAGELIST imageList;
3293     DWORD selectedCert;
3294 };
3295
3296 static LPARAM index_to_lparam(struct hierarchy_data *data, DWORD index)
3297 {
3298     CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
3299      (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
3300      data->pCertViewInfo->idxSigner, data->pCertViewInfo->fCounterSigner,
3301      data->pCertViewInfo->idxCounterSigner);
3302
3303     /* Takes advantage of the fact that a pointer is 32-bit aligned, and
3304      * therefore always even.
3305      */
3306     if (index == provSigner->csCertChain - 1)
3307         return (LPARAM)data;
3308     return index << 1 | 1;
3309 }
3310
3311 static inline DWORD lparam_to_index(struct hierarchy_data *data, LPARAM lp)
3312 {
3313     CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
3314      (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
3315      data->pCertViewInfo->idxSigner, data->pCertViewInfo->fCounterSigner,
3316      data->pCertViewInfo->idxCounterSigner);
3317
3318     if (!(lp & 1))
3319         return provSigner->csCertChain - 1;
3320     return lp >> 1;
3321 }
3322
3323 static struct hierarchy_data *get_hierarchy_data_from_tree_item(HWND tree,
3324  HTREEITEM hItem)
3325 {
3326     struct hierarchy_data *data = NULL;
3327     HTREEITEM root = NULL;
3328
3329     do {
3330         HTREEITEM parent = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM,
3331          TVGN_PARENT, (LPARAM)hItem);
3332
3333         if (!parent)
3334             root = hItem;
3335         hItem = parent;
3336     } while (hItem);
3337     if (root)
3338     {
3339         TVITEMW item;
3340
3341         item.mask = TVIF_PARAM;
3342         item.hItem = root;
3343         SendMessageW(tree, TVM_GETITEMW, 0, (LPARAM)&item);
3344         data = (struct hierarchy_data *)item.lParam;
3345     }
3346     return data;
3347 }
3348
3349 static WCHAR *get_cert_display_name(PCCERT_CONTEXT cert)
3350 {
3351     WCHAR *name = get_cert_property_as_string(cert, CERT_FRIENDLY_NAME_PROP_ID);
3352
3353     if (!name)
3354         name = get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0);
3355     return name;
3356 }
3357
3358 static void show_cert_chain(HWND hwnd, struct hierarchy_data *data)
3359 {
3360     HWND tree = GetDlgItem(hwnd, IDC_CERTPATH);
3361     CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
3362      (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
3363      data->pCertViewInfo->idxSigner, data->pCertViewInfo->fCounterSigner,
3364      data->pCertViewInfo->idxCounterSigner);
3365     DWORD i;
3366     HTREEITEM parent = NULL;
3367
3368     SendMessageW(tree, TVM_SETIMAGELIST, TVSIL_NORMAL, (LPARAM)data->imageList);
3369     for (i = provSigner->csCertChain; i; i--)
3370     {
3371         LPWSTR name;
3372
3373         name = get_cert_display_name(provSigner->pasCertChain[i - 1].pCert);
3374         if (name)
3375         {
3376             TVINSERTSTRUCTW tvis;
3377
3378             tvis.hParent = parent;
3379             tvis.hInsertAfter = TVI_LAST;
3380             tvis.u.item.mask = TVIF_TEXT | TVIF_STATE | TVIF_IMAGE |
3381              TVIF_SELECTEDIMAGE | TVIF_PARAM;
3382             tvis.u.item.pszText = name;
3383             tvis.u.item.state = TVIS_EXPANDED;
3384             tvis.u.item.stateMask = TVIS_EXPANDED;
3385             if (i == 1 &&
3386              (provSigner->pChainContext->TrustStatus.dwErrorStatus &
3387              CERT_TRUST_IS_PARTIAL_CHAIN))
3388             {
3389                 /* The root of the chain has a special case:  if the chain is
3390                  * a partial chain, the icon is a warning icon rather than an
3391                  * error icon.
3392                  */
3393                 tvis.u.item.iImage = 2;
3394             }
3395             else if (provSigner->pasCertChain[i - 1].pChainElement->TrustStatus.
3396              dwErrorStatus == 0)
3397                 tvis.u.item.iImage = 0;
3398             else
3399                 tvis.u.item.iImage = 1;
3400             tvis.u.item.iSelectedImage = tvis.u.item.iImage;
3401             tvis.u.item.lParam = index_to_lparam(data, i - 1);
3402             parent = (HTREEITEM)SendMessageW(tree, TVM_INSERTITEMW, 0,
3403              (LPARAM)&tvis);
3404             HeapFree(GetProcessHeap(), 0, name);
3405         }
3406     }
3407 }
3408
3409 static void set_certificate_status(HWND hwnd, CRYPT_PROVIDER_CERT *cert)
3410 {
3411     /* Select all the text in the control, the next update will replace it */
3412     SendMessageW(hwnd, EM_SETSEL, 0, -1);
3413     /* Set the highest priority error messages first. */
3414     if (!(cert->dwConfidence & CERT_CONFIDENCE_SIG))
3415         add_string_resource_to_control(hwnd, IDS_CERTIFICATE_BAD_SIGNATURE);
3416     else if (!(cert->dwConfidence & CERT_CONFIDENCE_TIME))
3417         add_string_resource_to_control(hwnd, IDS_CERTIFICATE_BAD_TIME);
3418     else if (!(cert->dwConfidence & CERT_CONFIDENCE_TIMENEST))
3419         add_string_resource_to_control(hwnd, IDS_CERTIFICATE_BAD_TIMENEST);
3420     else if (cert->dwRevokedReason)
3421         add_string_resource_to_control(hwnd, IDS_CERTIFICATE_REVOKED);
3422     else
3423         add_string_resource_to_control(hwnd, IDS_CERTIFICATE_VALID);
3424 }
3425
3426 static void set_certificate_status_for_end_cert(HWND hwnd,
3427  PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
3428 {
3429     HWND status = GetDlgItem(hwnd, IDC_CERTIFICATESTATUSTEXT);
3430     CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
3431      (CRYPT_PROVIDER_DATA *)pCertViewInfo->u.pCryptProviderData,
3432      pCertViewInfo->idxSigner, pCertViewInfo->fCounterSigner,
3433      pCertViewInfo->idxCounterSigner);
3434     CRYPT_PROVIDER_CERT *provCert = WTHelperGetProvCertFromChain(provSigner,
3435      pCertViewInfo->idxCert);
3436
3437     set_certificate_status(status, provCert);
3438 }
3439
3440 static void show_cert_hierarchy(HWND hwnd, struct hierarchy_data *data)
3441 {
3442     /* Disable view certificate button until a certificate is selected */
3443     EnableWindow(GetDlgItem(hwnd, IDC_VIEWCERTIFICATE), FALSE);
3444     show_cert_chain(hwnd, data);
3445     set_certificate_status_for_end_cert(hwnd, data->pCertViewInfo);
3446 }
3447
3448 static void show_dialog_for_selected_cert(HWND hwnd)
3449 {
3450     HWND tree = GetDlgItem(hwnd, IDC_CERTPATH);
3451     TVITEMW item;
3452     struct hierarchy_data *data;
3453     DWORD selection;
3454
3455     memset(&item, 0, sizeof(item));
3456     item.mask = TVIF_HANDLE | TVIF_PARAM;
3457     item.hItem = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM, TVGN_CARET,
3458      (LPARAM)NULL);
3459     SendMessageW(tree, TVM_GETITEMW, 0, (LPARAM)&item);
3460     data = get_hierarchy_data_from_tree_item(tree, item.hItem);
3461     selection = lparam_to_index(data, item.lParam);
3462     if (selection != 0)
3463     {
3464         CRYPT_PROVIDER_SGNR *provSigner;
3465         CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
3466         BOOL changed = FALSE;
3467
3468         provSigner = WTHelperGetProvSignerFromChain(
3469          (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
3470          data->pCertViewInfo->idxSigner,
3471          data->pCertViewInfo->fCounterSigner,
3472          data->pCertViewInfo->idxCounterSigner);
3473         memset(&viewInfo, 0, sizeof(viewInfo));
3474         viewInfo.dwSize = sizeof(viewInfo);
3475         viewInfo.dwFlags = data->pCertViewInfo->dwFlags;
3476         viewInfo.szTitle = data->pCertViewInfo->szTitle;
3477         viewInfo.pCertContext = provSigner->pasCertChain[selection].pCert;
3478         viewInfo.cStores = data->pCertViewInfo->cStores;
3479         viewInfo.rghStores = data->pCertViewInfo->rghStores;
3480         viewInfo.cPropSheetPages = data->pCertViewInfo->cPropSheetPages;
3481         viewInfo.rgPropSheetPages = data->pCertViewInfo->rgPropSheetPages;
3482         viewInfo.nStartPage = data->pCertViewInfo->nStartPage;
3483         CryptUIDlgViewCertificateW(&viewInfo, &changed);
3484         if (changed)
3485         {
3486             /* Delete the contents of the tree */
3487             SendMessageW(tree, TVM_DELETEITEM, 0, (LPARAM)TVI_ROOT);
3488             /* Reinitialize the tree */
3489             show_cert_hierarchy(hwnd, data);
3490         }
3491     }
3492 }
3493
3494 static LRESULT CALLBACK hierarchy_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
3495  LPARAM lp)
3496 {
3497     PROPSHEETPAGEW *page;
3498     struct hierarchy_data *data;
3499     LRESULT ret = 0;
3500     HWND tree = GetDlgItem(hwnd, IDC_CERTPATH);
3501
3502     TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
3503
3504     switch (msg)
3505     {
3506     case WM_INITDIALOG:
3507         page = (PROPSHEETPAGEW *)lp;
3508         data = (struct hierarchy_data *)page->lParam;
3509         show_cert_hierarchy(hwnd, data);
3510         break;
3511     case WM_NOTIFY:
3512     {
3513         NMHDR *hdr;
3514
3515         hdr = (NMHDR *)lp;
3516         switch (hdr->code)
3517         {
3518         case TVN_SELCHANGEDW:
3519         {
3520             NMTREEVIEWW *nm = (NMTREEVIEWW*)lp;
3521             DWORD selection;
3522             CRYPT_PROVIDER_SGNR *provSigner;
3523
3524             data = get_hierarchy_data_from_tree_item(tree, nm->itemNew.hItem);
3525             selection = lparam_to_index(data, nm->itemNew.lParam);
3526             provSigner = WTHelperGetProvSignerFromChain(
3527              (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
3528              data->pCertViewInfo->idxSigner,
3529              data->pCertViewInfo->fCounterSigner,
3530              data->pCertViewInfo->idxCounterSigner);
3531             EnableWindow(GetDlgItem(hwnd, IDC_VIEWCERTIFICATE), selection != 0);
3532             set_certificate_status(GetDlgItem(hwnd, IDC_CERTIFICATESTATUSTEXT),
3533              &provSigner->pasCertChain[selection]);
3534             break;
3535         }
3536         case NM_DBLCLK:
3537             show_dialog_for_selected_cert(hwnd);
3538             SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
3539             ret = 1;
3540             break;
3541         }
3542         break;
3543     }
3544     case WM_COMMAND:
3545         switch (wp)
3546         {
3547         case IDC_VIEWCERTIFICATE:
3548             show_dialog_for_selected_cert(hwnd);
3549             break;
3550         }
3551         break;
3552     case WM_REFRESH_VIEW:
3553     {
3554         TVITEMW item;
3555
3556         /* Get hierarchy data */
3557         memset(&item, 0, sizeof(item));
3558         item.mask = TVIF_HANDLE | TVIF_PARAM;
3559         item.hItem = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM, TVGN_ROOT,
3560          (LPARAM)NULL);
3561         data = get_hierarchy_data_from_tree_item(tree, item.hItem);
3562         /* Delete the contents of the tree */
3563         SendMessageW(tree, TVM_DELETEITEM, 0, (LPARAM)TVI_ROOT);
3564         /* Reinitialize the tree */
3565         show_cert_hierarchy(hwnd, data);
3566         break;
3567     }
3568     }
3569     return ret;
3570 }
3571
3572 static UINT CALLBACK hierarchy_callback(HWND hwnd, UINT msg,
3573  PROPSHEETPAGEW *page)
3574 {
3575     struct hierarchy_data *data;
3576
3577     switch (msg)
3578     {
3579     case PSPCB_RELEASE:
3580         data = (struct hierarchy_data *)page->lParam;
3581         ImageList_Destroy(data->imageList);
3582         HeapFree(GetProcessHeap(), 0, data);
3583         break;
3584     }
3585     return 0;
3586 }
3587
3588 static BOOL init_hierarchy_page(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
3589  PROPSHEETPAGEW *page)
3590 {
3591     struct hierarchy_data *data = HeapAlloc(GetProcessHeap(), 0,
3592      sizeof(struct hierarchy_data));
3593     BOOL ret = FALSE;
3594
3595     if (data)
3596     {
3597         data->imageList = ImageList_Create(16, 16, ILC_COLOR4 | ILC_MASK, 2, 0);
3598         if (data->imageList)
3599         {
3600             HBITMAP bmp;
3601             COLORREF backColor = RGB(255, 0, 255);
3602
3603             data->pCertViewInfo = pCertViewInfo;
3604             data->selectedCert = 0xffffffff;
3605
3606             bmp = LoadBitmapW(hInstance, MAKEINTRESOURCEW(IDB_SMALL_ICONS));
3607             ImageList_AddMasked(data->imageList, bmp, backColor);
3608             DeleteObject(bmp);
3609             ImageList_SetBkColor(data->imageList, CLR_NONE);
3610
3611             memset(page, 0, sizeof(PROPSHEETPAGEW));
3612             page->dwSize = sizeof(PROPSHEETPAGEW);
3613             page->dwFlags = PSP_USECALLBACK;
3614             page->hInstance = hInstance;
3615             page->u.pszTemplate = MAKEINTRESOURCEW(IDD_HIERARCHY);
3616             page->pfnDlgProc = hierarchy_dlg_proc;
3617             page->lParam = (LPARAM)data;
3618             page->pfnCallback = hierarchy_callback;
3619             ret = TRUE;
3620         }
3621         else
3622             HeapFree(GetProcessHeap(), 0, data);
3623     }
3624     return ret;
3625 }
3626
3627 static int CALLBACK cert_prop_sheet_proc(HWND hwnd, UINT msg, LPARAM lp)
3628 {
3629     RECT rc;
3630     POINT topLeft;
3631
3632     TRACE("(%p, %08x, %08lx)\n", hwnd, msg, lp);
3633
3634     switch (msg)
3635     {
3636     case PSCB_INITIALIZED:
3637         /* Get cancel button's position.. */
3638         GetWindowRect(GetDlgItem(hwnd, IDCANCEL), &rc);
3639         topLeft.x = rc.left;
3640         topLeft.y = rc.top;
3641         ScreenToClient(hwnd, &topLeft);
3642         /* hide the cancel button.. */
3643         ShowWindow(GetDlgItem(hwnd, IDCANCEL), FALSE);
3644         /* get the OK button's size.. */
3645         GetWindowRect(GetDlgItem(hwnd, IDOK), &rc);
3646         /* and move the OK button to the cancel button's original position. */
3647         MoveWindow(GetDlgItem(hwnd, IDOK), topLeft.x, topLeft.y,
3648          rc.right - rc.left, rc.bottom - rc.top, FALSE);
3649         GetWindowRect(GetDlgItem(hwnd, IDOK), &rc);
3650         break;
3651     }
3652     return 0;
3653 }
3654
3655 static BOOL show_cert_dialog(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
3656  CRYPT_PROVIDER_CERT *provCert, BOOL *pfPropertiesChanged)
3657 {
3658     static const WCHAR riched[] = { 'r','i','c','h','e','d','2','0',0 };
3659     DWORD nPages;
3660     PROPSHEETPAGEW *pages;
3661     BOOL ret = FALSE;
3662     HMODULE lib = LoadLibraryW(riched);
3663
3664     nPages = pCertViewInfo->cPropSheetPages + 1; /* one for the General tab */
3665     if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_DETAILPAGE))
3666         nPages++;
3667     if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_HIERARCHYPAGE))
3668         nPages++;
3669     pages = HeapAlloc(GetProcessHeap(), 0, nPages * sizeof(PROPSHEETPAGEW));
3670     if (pages)
3671     {
3672         PROPSHEETHEADERW hdr;
3673         CRYPTUI_INITDIALOG_STRUCT *init = NULL;
3674         DWORD i;
3675
3676         memset(&hdr, 0, sizeof(hdr));
3677         hdr.dwSize = sizeof(hdr);
3678         hdr.dwFlags = PSH_NOAPPLYNOW | PSH_PROPSHEETPAGE | PSH_USECALLBACK;
3679         hdr.hInstance = hInstance;
3680         if (pCertViewInfo->szTitle)
3681             hdr.pszCaption = pCertViewInfo->szTitle;
3682         else
3683             hdr.pszCaption = MAKEINTRESOURCEW(IDS_CERTIFICATE);
3684         init_general_page(pCertViewInfo, &pages[hdr.nPages++]);
3685         if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_DETAILPAGE))
3686         {
3687             if (init_detail_page(pCertViewInfo, pfPropertiesChanged,
3688              &pages[hdr.nPages]))
3689                 hdr.nPages++;
3690         }
3691         if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_HIERARCHYPAGE))
3692         {
3693             if (init_hierarchy_page(pCertViewInfo, &pages[hdr.nPages]))
3694                 hdr.nPages++;
3695         }
3696         /* Copy each additional page, and create the init dialog struct for it
3697          */
3698         if (pCertViewInfo->cPropSheetPages)
3699         {
3700             init = HeapAlloc(GetProcessHeap(), 0,
3701              pCertViewInfo->cPropSheetPages *
3702              sizeof(CRYPTUI_INITDIALOG_STRUCT));
3703             if (init)
3704             {
3705                 for (i = 0; i < pCertViewInfo->cPropSheetPages; i++)
3706                 {
3707                     memcpy(&pages[hdr.nPages + i],
3708                      &pCertViewInfo->rgPropSheetPages[i],
3709                      sizeof(PROPSHEETPAGEW));
3710                     init[i].lParam = pCertViewInfo->rgPropSheetPages[i].lParam;
3711                     init[i].pCertContext = pCertViewInfo->pCertContext;
3712                     pages[hdr.nPages + i].lParam = (LPARAM)&init[i];
3713                 }
3714                 if (pCertViewInfo->nStartPage & 0x8000)
3715                 {
3716                     /* Start page index is relative to the number of default
3717                      * pages
3718                      */
3719                     hdr.u2.nStartPage = pCertViewInfo->nStartPage + hdr.nPages;
3720                 }
3721                 else
3722                     hdr.u2.nStartPage = pCertViewInfo->nStartPage;
3723                 hdr.nPages = nPages;
3724                 ret = TRUE;
3725             }
3726             else
3727                 SetLastError(ERROR_OUTOFMEMORY);
3728         }
3729         else
3730         {
3731             /* Ignore the relative flag if there aren't any additional pages */
3732             hdr.u2.nStartPage = pCertViewInfo->nStartPage & 0x7fff;
3733             ret = TRUE;
3734         }
3735         if (ret)
3736         {
3737             INT_PTR l;
3738
3739             hdr.u3.ppsp = pages;
3740             hdr.pfnCallback = cert_prop_sheet_proc;
3741             l = PropertySheetW(&hdr);
3742             if (l == 0)
3743             {
3744                 SetLastError(ERROR_CANCELLED);
3745                 ret = FALSE;
3746             }
3747         }
3748         HeapFree(GetProcessHeap(), 0, init);
3749         HeapFree(GetProcessHeap(), 0, pages);
3750     }
3751     else
3752         SetLastError(ERROR_OUTOFMEMORY);
3753     FreeLibrary(lib);
3754     return ret;
3755 }
3756
3757 /***********************************************************************
3758  *              CryptUIDlgViewCertificateW (CRYPTUI.@)
3759  */
3760 BOOL WINAPI CryptUIDlgViewCertificateW(
3761  PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo, BOOL *pfPropertiesChanged)
3762 {
3763     static GUID generic_cert_verify = WINTRUST_ACTION_GENERIC_CERT_VERIFY;
3764     CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
3765     WINTRUST_DATA wvt;
3766     WINTRUST_CERT_INFO cert;
3767     BOOL ret = FALSE;
3768     CRYPT_PROVIDER_SGNR *signer;
3769     CRYPT_PROVIDER_CERT *provCert = NULL;
3770
3771     TRACE("(%p, %p)\n", pCertViewInfo, pfPropertiesChanged);
3772
3773     if (pCertViewInfo->dwSize != sizeof(CRYPTUI_VIEWCERTIFICATE_STRUCTW))
3774     {
3775         SetLastError(ERROR_INVALID_PARAMETER);
3776         return FALSE;
3777     }
3778     /* Make a local copy in case we have to call WinVerifyTrust ourselves */
3779     memcpy(&viewInfo, pCertViewInfo, sizeof(viewInfo));
3780     if (!viewInfo.u.hWVTStateData)
3781     {
3782         memset(&wvt, 0, sizeof(wvt));
3783         wvt.cbStruct = sizeof(wvt);
3784         wvt.dwUIChoice = WTD_UI_NONE;
3785         if (viewInfo.dwFlags &
3786          CRYPTUI_ENABLE_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT)
3787             wvt.fdwRevocationChecks |= WTD_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT;
3788         if (viewInfo.dwFlags & CRYPTUI_ENABLE_REVOCATION_CHECK_END_CERT)
3789             wvt.fdwRevocationChecks |= WTD_REVOCATION_CHECK_END_CERT;
3790         if (viewInfo.dwFlags & CRYPTUI_ENABLE_REVOCATION_CHECK_CHAIN)
3791             wvt.fdwRevocationChecks |= WTD_REVOCATION_CHECK_CHAIN;
3792         wvt.dwUnionChoice = WTD_CHOICE_CERT;
3793         memset(&cert, 0, sizeof(cert));
3794         cert.cbStruct = sizeof(cert);
3795         cert.psCertContext = (CERT_CONTEXT *)viewInfo.pCertContext;
3796         cert.chStores = viewInfo.cStores;
3797         cert.pahStores = viewInfo.rghStores;
3798         wvt.u.pCert = &cert;
3799         wvt.dwStateAction = WTD_STATEACTION_VERIFY;
3800         WinVerifyTrust(NULL, &generic_cert_verify, &wvt);
3801         viewInfo.u.pCryptProviderData =
3802          WTHelperProvDataFromStateData(wvt.hWVTStateData);
3803         signer = WTHelperGetProvSignerFromChain(
3804          (CRYPT_PROVIDER_DATA *)viewInfo.u.pCryptProviderData, 0, FALSE, 0);
3805         provCert = WTHelperGetProvCertFromChain(signer, 0);
3806         ret = TRUE;
3807     }
3808     else
3809     {
3810         viewInfo.u.pCryptProviderData =
3811          WTHelperProvDataFromStateData(viewInfo.u.hWVTStateData);
3812         signer = WTHelperGetProvSignerFromChain(
3813          (CRYPT_PROVIDER_DATA *)viewInfo.u.pCryptProviderData,
3814          viewInfo.idxSigner, viewInfo.fCounterSigner,
3815          viewInfo.idxCounterSigner);
3816         provCert = WTHelperGetProvCertFromChain(signer, viewInfo.idxCert);
3817         ret = TRUE;
3818     }
3819     if (ret)
3820     {
3821         ret = show_cert_dialog(&viewInfo, provCert, pfPropertiesChanged);
3822         if (!viewInfo.u.hWVTStateData)
3823         {
3824             wvt.dwStateAction = WTD_STATEACTION_CLOSE;
3825             WinVerifyTrust(NULL, &generic_cert_verify, &wvt);
3826         }
3827     }
3828     return ret;
3829 }
3830
3831 /***********************************************************************
3832  *              CryptUIDlgViewContext (CRYPTUI.@)
3833  */
3834 BOOL WINAPI CryptUIDlgViewContext(DWORD dwContextType, LPVOID pvContext,
3835  HWND hwnd, LPCWSTR pwszTitle, DWORD dwFlags, LPVOID pvReserved)
3836 {
3837     BOOL ret;
3838
3839     TRACE("(%d, %p, %p, %s, %08x, %p)\n", dwContextType, pvContext, hwnd,
3840      debugstr_w(pwszTitle), dwFlags, pvReserved);
3841
3842     switch (dwContextType)
3843     {
3844     case CERT_STORE_CERTIFICATE_CONTEXT:
3845     {
3846         CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
3847
3848         memset(&viewInfo, 0, sizeof(viewInfo));
3849         viewInfo.dwSize = sizeof(viewInfo);
3850         viewInfo.hwndParent = hwnd;
3851         viewInfo.szTitle = pwszTitle;
3852         viewInfo.pCertContext = pvContext;
3853         ret = CryptUIDlgViewCertificateW(&viewInfo, NULL);
3854         break;
3855     }
3856     default:
3857         FIXME("unimplemented for context type %d\n", dwContextType);
3858         SetLastError(E_INVALIDARG);
3859         ret = FALSE;
3860     }
3861     return ret;
3862 }
3863
3864 /* Decodes a cert's basic constraints extension (either szOID_BASIC_CONSTRAINTS
3865  * or szOID_BASIC_CONSTRAINTS2, whichever is present) to determine if it
3866  * should be a CA.  If neither extension is present, returns
3867  * defaultIfNotSpecified.
3868  */
3869 static BOOL is_ca_cert(PCCERT_CONTEXT cert, BOOL defaultIfNotSpecified)
3870 {
3871     BOOL isCA = defaultIfNotSpecified;
3872     PCERT_EXTENSION ext = CertFindExtension(szOID_BASIC_CONSTRAINTS,
3873      cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
3874
3875     if (ext)
3876     {
3877         CERT_BASIC_CONSTRAINTS_INFO *info;
3878         DWORD size = 0;
3879
3880         if (CryptDecodeObjectEx(X509_ASN_ENCODING, szOID_BASIC_CONSTRAINTS,
3881          ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_ALLOC_FLAG,
3882          NULL, (LPBYTE)&info, &size))
3883         {
3884             if (info->SubjectType.cbData == 1)
3885                 isCA = info->SubjectType.pbData[0] & CERT_CA_SUBJECT_FLAG;
3886             LocalFree(info);
3887         }
3888     }
3889     else
3890     {
3891         ext = CertFindExtension(szOID_BASIC_CONSTRAINTS2,
3892          cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
3893         if (ext)
3894         {
3895             CERT_BASIC_CONSTRAINTS2_INFO info;
3896             DWORD size = sizeof(CERT_BASIC_CONSTRAINTS2_INFO);
3897
3898             if (CryptDecodeObjectEx(X509_ASN_ENCODING,
3899              szOID_BASIC_CONSTRAINTS2, ext->Value.pbData, ext->Value.cbData,
3900              0, NULL, &info, &size))
3901                 isCA = info.fCA;
3902         }
3903     }
3904     return isCA;
3905 }
3906
3907 static HCERTSTORE choose_store_for_cert(PCCERT_CONTEXT cert)
3908 {
3909     LPCWSTR storeName;
3910
3911     if (is_ca_cert(cert, TRUE))
3912         storeName = ca;
3913     else
3914         storeName = addressBook;
3915     return CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0,
3916      CERT_SYSTEM_STORE_CURRENT_USER, storeName);
3917 }
3918
3919 static BOOL import_cert(PCCERT_CONTEXT cert, HCERTSTORE hDestCertStore)
3920 {
3921     HCERTSTORE store;
3922     BOOL ret;
3923
3924     if (!cert)
3925     {
3926         SetLastError(E_INVALIDARG);
3927         return FALSE;
3928     }
3929     if (hDestCertStore) store = hDestCertStore;
3930     else
3931     {
3932         if (!(store = choose_store_for_cert(cert)))
3933         {
3934             WARN("unable to open certificate store\n");
3935             return FALSE;
3936         }
3937     }
3938     ret = CertAddCertificateContextToStore(store, cert,
3939      CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES, NULL);
3940     if (!hDestCertStore) CertCloseStore(store, 0);
3941     return ret;
3942 }
3943
3944 static BOOL import_crl(PCCRL_CONTEXT crl, HCERTSTORE hDestCertStore)
3945 {
3946     HCERTSTORE store;
3947     BOOL ret;
3948
3949     if (!crl)
3950     {
3951         SetLastError(E_INVALIDARG);
3952         return FALSE;
3953     }
3954     if (hDestCertStore) store = hDestCertStore;
3955     else
3956     {
3957         if (!(store = CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0,
3958          CERT_SYSTEM_STORE_CURRENT_USER, ca)))
3959         {
3960             WARN("unable to open certificate store\n");
3961             return FALSE;
3962         }
3963     }
3964     ret = CertAddCRLContextToStore(store, crl,
3965      CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES, NULL);
3966     if (!hDestCertStore) CertCloseStore(store, 0);
3967     return ret;
3968 }
3969
3970 static BOOL import_ctl(PCCTL_CONTEXT ctl, HCERTSTORE hDestCertStore)
3971 {
3972     HCERTSTORE store;
3973     BOOL ret;
3974
3975     if (!ctl)
3976     {
3977         SetLastError(E_INVALIDARG);
3978         return FALSE;
3979     }
3980     if (hDestCertStore) store = hDestCertStore;
3981     else
3982     {
3983         static const WCHAR trust[] = { 'T','r','u','s','t',0 };
3984
3985         if (!(store = CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0,
3986          CERT_SYSTEM_STORE_CURRENT_USER, trust)))
3987         {
3988             WARN("unable to open certificate store\n");
3989             return FALSE;
3990         }
3991     }
3992     ret = CertAddCTLContextToStore(store, ctl,
3993      CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES, NULL);
3994     if (!hDestCertStore) CertCloseStore(store, 0);
3995     return ret;
3996 }
3997
3998 /* Checks type, a type such as CERT_QUERY_CONTENT_CERT returned by
3999  * CryptQueryObject, against the allowed types.  Returns TRUE if the
4000  * type is allowed, FALSE otherwise.
4001  */
4002 static BOOL check_context_type(DWORD dwFlags, DWORD type)
4003 {
4004     BOOL ret;
4005
4006     if (dwFlags &
4007      (CRYPTUI_WIZ_IMPORT_ALLOW_CERT | CRYPTUI_WIZ_IMPORT_ALLOW_CRL |
4008      CRYPTUI_WIZ_IMPORT_ALLOW_CTL))
4009     {
4010         switch (type)
4011         {
4012         case CERT_QUERY_CONTENT_CERT:
4013         case CERT_QUERY_CONTENT_SERIALIZED_CERT:
4014             ret = dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CERT;
4015             break;
4016         case CERT_QUERY_CONTENT_CRL:
4017         case CERT_QUERY_CONTENT_SERIALIZED_CRL:
4018             ret = dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CRL;
4019             break;
4020         case CERT_QUERY_CONTENT_CTL:
4021         case CERT_QUERY_CONTENT_SERIALIZED_CTL:
4022             ret = dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CTL;
4023             break;
4024         default:
4025             /* The remaining types contain more than one type, so allow
4026              * any combination.
4027              */
4028             ret = TRUE;
4029         }
4030     }
4031     else
4032     {
4033         /* No allowed types specified, so any type is allowed */
4034         ret = TRUE;
4035     }
4036     if (!ret)
4037         SetLastError(E_INVALIDARG);
4038     return ret;
4039 }
4040
4041
4042 static void import_warning(DWORD dwFlags, HWND hwnd, LPCWSTR szTitle,
4043  int warningID)
4044 {
4045     if (!(dwFlags & CRYPTUI_WIZ_NO_UI))
4046     {
4047         WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
4048         LPCWSTR pTitle;
4049
4050         if (szTitle)
4051             pTitle = szTitle;
4052         else
4053         {
4054             LoadStringW(hInstance, IDS_IMPORT_WIZARD, title,
4055              sizeof(title) / sizeof(title[0]));
4056             pTitle = title;
4057         }
4058         LoadStringW(hInstance, warningID, error,
4059          sizeof(error) / sizeof(error[0]));
4060         MessageBoxW(hwnd, error, pTitle, MB_ICONERROR | MB_OK);
4061     }
4062 }
4063
4064 static void import_warn_type_mismatch(DWORD dwFlags, HWND hwnd, LPCWSTR szTitle)
4065 {
4066     import_warning(dwFlags, hwnd, szTitle, IDS_IMPORT_TYPE_MISMATCH);
4067 }
4068
4069 static BOOL check_store_context_type(DWORD dwFlags, HCERTSTORE store)
4070 {
4071     BOOL ret;
4072
4073     if (dwFlags &
4074      (CRYPTUI_WIZ_IMPORT_ALLOW_CERT | CRYPTUI_WIZ_IMPORT_ALLOW_CRL |
4075      CRYPTUI_WIZ_IMPORT_ALLOW_CTL))
4076     {
4077         PCCERT_CONTEXT cert;
4078         PCCRL_CONTEXT crl;
4079         PCCTL_CONTEXT ctl;
4080
4081         ret = TRUE;
4082         if ((cert = CertEnumCertificatesInStore(store, NULL)))
4083         {
4084             CertFreeCertificateContext(cert);
4085             if (!(dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CERT))
4086                 ret = FALSE;
4087         }
4088         if (ret && (crl = CertEnumCRLsInStore(store, NULL)))
4089         {
4090             CertFreeCRLContext(crl);
4091             if (!(dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CRL))
4092                 ret = FALSE;
4093         }
4094         if (ret && (ctl = CertEnumCTLsInStore(store, NULL)))
4095         {
4096             CertFreeCTLContext(ctl);
4097             if (!(dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CTL))
4098                 ret = FALSE;
4099         }
4100     }
4101     else
4102         ret = TRUE;
4103     if (!ret)
4104         SetLastError(E_INVALIDARG);
4105     return ret;
4106 }
4107
4108 static BOOL import_store(DWORD dwFlags, HWND hwnd, LPCWSTR szTitle,
4109  HCERTSTORE source, HCERTSTORE dest)
4110 {
4111     BOOL ret;
4112
4113     if ((ret = check_store_context_type(dwFlags, source)))
4114     {
4115         PCCERT_CONTEXT cert = NULL;
4116         PCCRL_CONTEXT crl = NULL;
4117         PCCTL_CONTEXT ctl = NULL;
4118
4119         do {
4120             cert = CertEnumCertificatesInStore(source, cert);
4121             if (cert)
4122                 ret = import_cert(cert, dest);
4123         } while (ret && cert);
4124         do {
4125             crl = CertEnumCRLsInStore(source, crl);
4126             if (crl)
4127                 ret = import_crl(crl, dest);
4128         } while (ret && crl);
4129         do {
4130             ctl = CertEnumCTLsInStore(source, ctl);
4131             if (ctl)
4132                 ret = import_ctl(ctl, dest);
4133         } while (ret && ctl);
4134     }
4135     else
4136         import_warn_type_mismatch(dwFlags, hwnd, szTitle);
4137     return ret;
4138 }
4139
4140 static HCERTSTORE open_store_from_file(DWORD dwFlags, LPCWSTR fileName,
4141  DWORD *pContentType)
4142 {
4143     HCERTSTORE store = NULL;
4144     DWORD contentType = 0, expectedContentTypeFlags;
4145
4146     if (dwFlags &
4147      (CRYPTUI_WIZ_IMPORT_ALLOW_CERT | CRYPTUI_WIZ_IMPORT_ALLOW_CRL |
4148      CRYPTUI_WIZ_IMPORT_ALLOW_CTL))
4149     {
4150         expectedContentTypeFlags =
4151          CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE |
4152          CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED |
4153          CERT_QUERY_CONTENT_FLAG_PFX;
4154         if (dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CERT)
4155             expectedContentTypeFlags |=
4156              CERT_QUERY_CONTENT_FLAG_CERT |
4157              CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT;
4158         if (dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CRL)
4159             expectedContentTypeFlags |=
4160              CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL |
4161              CERT_QUERY_CONTENT_FLAG_CRL;
4162         if (dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CTL)
4163             expectedContentTypeFlags |=
4164              CERT_QUERY_CONTENT_FLAG_CTL |
4165              CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL;
4166     }
4167     else
4168         expectedContentTypeFlags =
4169          CERT_QUERY_CONTENT_FLAG_CERT |
4170          CERT_QUERY_CONTENT_FLAG_CTL |
4171          CERT_QUERY_CONTENT_FLAG_CRL |
4172          CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE |
4173          CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT |
4174          CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL |
4175          CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL |
4176          CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED |
4177          CERT_QUERY_CONTENT_FLAG_PFX;
4178
4179     CryptQueryObject(CERT_QUERY_OBJECT_FILE, fileName,
4180      expectedContentTypeFlags, CERT_QUERY_FORMAT_FLAG_ALL, 0, NULL,
4181      &contentType, NULL, &store, NULL, NULL);
4182     if (pContentType)
4183         *pContentType = contentType;
4184     return store;
4185 }
4186
4187 static BOOL import_file(DWORD dwFlags, HWND hwnd, LPCWSTR szTitle,
4188  LPCWSTR fileName, HCERTSTORE dest)
4189 {
4190     HCERTSTORE source;
4191     BOOL ret;
4192
4193     if ((source = open_store_from_file(dwFlags, fileName, NULL)))
4194     {
4195         ret = import_store(dwFlags, hwnd, szTitle, source, dest);
4196         CertCloseStore(source, 0);
4197     }
4198     else
4199         ret = FALSE;
4200     return ret;
4201 }
4202
4203 struct ImportWizData
4204 {
4205     HFONT titleFont;
4206     DWORD dwFlags;
4207     LPCWSTR pwszWizardTitle;
4208     CRYPTUI_WIZ_IMPORT_SRC_INFO importSrc;
4209     LPWSTR fileName;
4210     DWORD contentType;
4211     BOOL freeSource;
4212     HCERTSTORE hDestCertStore;
4213     BOOL freeDest;
4214     BOOL autoDest;
4215     BOOL success;
4216 };
4217
4218 static LRESULT CALLBACK import_welcome_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
4219  LPARAM lp)
4220 {
4221     LRESULT ret = 0;
4222
4223     switch (msg)
4224     {
4225     case WM_INITDIALOG:
4226     {
4227         struct ImportWizData *data;
4228         PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
4229         WCHAR fontFace[MAX_STRING_LEN];
4230         HDC hDC = GetDC(hwnd);
4231         int height;
4232
4233         data = (struct ImportWizData *)page->lParam;
4234         LoadStringW(hInstance, IDS_WIZARD_TITLE_FONT, fontFace,
4235          sizeof(fontFace) / sizeof(fontFace[0]));
4236         height = -MulDiv(12, GetDeviceCaps(hDC, LOGPIXELSY), 72);
4237         data->titleFont = CreateFontW(height, 0, 0, 0, FW_BOLD, 0, 0, 0,
4238          DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
4239          DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, fontFace);
4240         SendMessageW(GetDlgItem(hwnd, IDC_IMPORT_TITLE), WM_SETFONT,
4241          (WPARAM)data->titleFont, TRUE);
4242         ReleaseDC(hwnd, hDC);
4243         break;
4244     }
4245     case WM_NOTIFY:
4246     {
4247         NMHDR *hdr = (NMHDR *)lp;
4248
4249         switch (hdr->code)
4250         {
4251         case PSN_SETACTIVE:
4252             PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0, PSWIZB_NEXT);
4253             ret = TRUE;
4254             break;
4255         }
4256         break;
4257     }
4258     }
4259     return ret;
4260 }
4261
4262 static const WCHAR filter_cert[] = { '*','.','c','e','r',';','*','.',
4263  'c','r','t',0 };
4264 static const WCHAR filter_pfx[] = { '*','.','p','f','x',';','*','.',
4265  'p','1','2',0 };
4266 static const WCHAR filter_crl[] = { '*','.','c','r','l',0 };
4267 static const WCHAR filter_ctl[] = { '*','.','s','t','l',0 };
4268 static const WCHAR filter_serialized_store[] = { '*','.','s','s','t',0 };
4269 static const WCHAR filter_cms[] = { '*','.','s','p','c',';','*','.',
4270  'p','7','b',0 };
4271 static const WCHAR filter_all[] = { '*','.','*',0 };
4272
4273 struct StringToFilter
4274 {
4275     int     id;
4276     DWORD   allowFlags;
4277     LPCWSTR filter;
4278 } import_filters[] = {
4279  { IDS_IMPORT_FILTER_CERT, CRYPTUI_WIZ_IMPORT_ALLOW_CERT, filter_cert },
4280  { IDS_IMPORT_FILTER_PFX, 0, filter_pfx },
4281  { IDS_IMPORT_FILTER_CRL, CRYPTUI_WIZ_IMPORT_ALLOW_CRL, filter_crl },
4282  { IDS_IMPORT_FILTER_CTL, CRYPTUI_WIZ_IMPORT_ALLOW_CTL, filter_ctl },
4283  { IDS_IMPORT_FILTER_SERIALIZED_STORE, 0, filter_serialized_store },
4284  { IDS_IMPORT_FILTER_CMS, 0, filter_cms },
4285  { IDS_IMPORT_FILTER_ALL, 0, filter_all },
4286 };
4287
4288 static WCHAR *make_import_file_filter(DWORD dwFlags)
4289 {
4290     DWORD i;
4291     int len, totalLen = 2;
4292     LPWSTR filter = NULL, str;
4293
4294     for (i = 0; i < sizeof(import_filters) / sizeof(import_filters[0]); i++)
4295     {
4296         if (!import_filters[i].allowFlags || !dwFlags ||
4297          (dwFlags & import_filters[i].allowFlags))
4298         {
4299             len = LoadStringW(hInstance, import_filters[i].id, (LPWSTR)&str, 0);
4300             totalLen += len + strlenW(import_filters[i].filter) + 2;
4301         }
4302     }
4303     filter = HeapAlloc(GetProcessHeap(), 0, totalLen * sizeof(WCHAR));
4304     if (filter)
4305     {
4306         LPWSTR ptr;
4307
4308         ptr = filter;
4309         for (i = 0; i < sizeof(import_filters) / sizeof(import_filters[0]); i++)
4310         {
4311             if (!import_filters[i].allowFlags || !dwFlags ||
4312              (dwFlags & import_filters[i].allowFlags))
4313             {
4314                 len = LoadStringW(hInstance, import_filters[i].id,
4315                  (LPWSTR)&str, 0);
4316                 memcpy(ptr, str, len * sizeof(WCHAR));
4317                 ptr += len;
4318                 *ptr++ = 0;
4319                 strcpyW(ptr, import_filters[i].filter);
4320                 ptr += strlenW(import_filters[i].filter) + 1;
4321             }
4322         }
4323         *ptr++ = 0;
4324     }
4325     return filter;
4326 }
4327
4328 static BOOL import_validate_filename(HWND hwnd, struct ImportWizData *data,
4329  LPCWSTR fileName)
4330 {
4331     HANDLE file;
4332     BOOL ret = FALSE;
4333
4334     file = CreateFileW(fileName, GENERIC_READ, FILE_SHARE_READ, NULL,
4335      OPEN_EXISTING, 0, NULL);
4336     if (file != INVALID_HANDLE_VALUE)
4337     {
4338         HCERTSTORE source = open_store_from_file(data->dwFlags, fileName,
4339          &data->contentType);
4340         int warningID = 0;
4341
4342         if (!source)
4343             warningID = IDS_IMPORT_BAD_FORMAT;
4344         else if (!check_store_context_type(data->dwFlags, source))
4345             warningID = IDS_IMPORT_TYPE_MISMATCH;
4346         else
4347         {
4348             data->importSrc.dwSubjectChoice =
4349              CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_STORE;
4350             data->importSrc.u.hCertStore = source;
4351             data->freeSource = TRUE;
4352             ret = TRUE;
4353         }
4354         if (warningID)
4355         {
4356             import_warning(data->dwFlags, hwnd, data->pwszWizardTitle,
4357              warningID);
4358         }
4359         CloseHandle(file);
4360     }
4361     else
4362     {
4363         WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
4364         LPCWSTR pTitle;
4365         LPWSTR msgBuf, fullError;
4366
4367         if (data->pwszWizardTitle)
4368             pTitle = data->pwszWizardTitle;
4369         else
4370         {
4371             LoadStringW(hInstance, IDS_IMPORT_WIZARD, title,
4372              sizeof(title) / sizeof(title[0]));
4373             pTitle = title;
4374         }
4375         LoadStringW(hInstance, IDS_IMPORT_OPEN_FAILED, error,
4376          sizeof(error) / sizeof(error[0]));
4377         FormatMessageW(
4378          FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL,
4379          GetLastError(), 0, (LPWSTR) &msgBuf, 0, NULL);
4380         fullError = HeapAlloc(GetProcessHeap(), 0,
4381          (strlenW(error) + strlenW(fileName) + strlenW(msgBuf) + 3)
4382          * sizeof(WCHAR));
4383         if (fullError)
4384         {
4385             LPWSTR ptr = fullError;
4386
4387             strcpyW(ptr, error);
4388             ptr += strlenW(error);
4389             strcpyW(ptr, fileName);
4390             ptr += strlenW(fileName);
4391             *ptr++ = ':';
4392             *ptr++ = '\n';
4393             strcpyW(ptr, msgBuf);
4394             MessageBoxW(hwnd, fullError, pTitle, MB_ICONERROR | MB_OK);
4395             HeapFree(GetProcessHeap(), 0, fullError);
4396         }
4397         LocalFree(msgBuf);
4398     }
4399     return ret;
4400 }
4401
4402 static LRESULT CALLBACK import_file_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
4403  LPARAM lp)
4404 {
4405     LRESULT ret = 0;
4406     struct ImportWizData *data;
4407
4408     switch (msg)
4409     {
4410     case WM_INITDIALOG:
4411     {
4412         PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
4413
4414         data = (struct ImportWizData *)page->lParam;
4415         SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
4416         break;
4417     }
4418     case WM_NOTIFY:
4419     {
4420         NMHDR *hdr = (NMHDR *)lp;
4421
4422         switch (hdr->code)
4423         {
4424         case PSN_SETACTIVE:
4425             PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
4426              PSWIZB_BACK | PSWIZB_NEXT);
4427             ret = TRUE;
4428             break;
4429         case PSN_WIZNEXT:
4430         {
4431             HWND fileNameEdit = GetDlgItem(hwnd, IDC_IMPORT_FILENAME);
4432             DWORD len = SendMessageW(fileNameEdit, WM_GETTEXTLENGTH, 0, 0);
4433
4434             data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
4435             if (!len)
4436             {
4437                 import_warning(data->dwFlags, hwnd, data->pwszWizardTitle,
4438                  IDS_IMPORT_EMPTY_FILE);
4439                 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
4440                 ret = 1;
4441             }
4442             else
4443             {
4444                 LPWSTR fileName = HeapAlloc(GetProcessHeap(), 0,
4445                  (len + 1) * sizeof(WCHAR));
4446
4447                 if (fileName)
4448                 {
4449                     SendMessageW(fileNameEdit, WM_GETTEXT, len + 1,
4450                      (LPARAM)fileName);
4451                     if (!import_validate_filename(hwnd, data, fileName))
4452                     {
4453                         HeapFree(GetProcessHeap(), 0, fileName);
4454                         SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
4455                         ret = 1;
4456                     }
4457                     else
4458                         data->fileName = fileName;
4459                 }
4460             }
4461             break;
4462         }
4463         }
4464         break;
4465     }
4466     case WM_COMMAND:
4467         switch (wp)
4468         {
4469         case IDC_IMPORT_BROWSE_FILE:
4470         {
4471             OPENFILENAMEW ofn;
4472             WCHAR fileBuf[MAX_PATH];
4473
4474             data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
4475             memset(&ofn, 0, sizeof(ofn));
4476             ofn.lStructSize = sizeof(ofn);
4477             ofn.hwndOwner = hwnd;
4478             ofn.lpstrFilter = make_import_file_filter(data->dwFlags);
4479             ofn.lpstrFile = fileBuf;
4480             ofn.nMaxFile = sizeof(fileBuf) / sizeof(fileBuf[0]);
4481             fileBuf[0] = 0;
4482             if (GetOpenFileNameW(&ofn))
4483                 SendMessageW(GetDlgItem(hwnd, IDC_IMPORT_FILENAME), WM_SETTEXT,
4484                  0, (LPARAM)ofn.lpstrFile);
4485             HeapFree(GetProcessHeap(), 0, (LPWSTR)ofn.lpstrFilter);
4486             break;
4487         }
4488         }
4489         break;
4490     }
4491     return ret;
4492 }
4493
4494 static LRESULT CALLBACK import_store_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
4495  LPARAM lp)
4496 {
4497     LRESULT ret = 0;
4498     struct ImportWizData *data;
4499
4500     switch (msg)
4501     {
4502     case WM_INITDIALOG:
4503     {
4504         PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
4505
4506         data = (struct ImportWizData *)page->lParam;
4507         SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
4508         SendMessageW(GetDlgItem(hwnd, IDC_IMPORT_AUTO_STORE), BM_CLICK, 0, 0);
4509         if (data->dwFlags & CRYPTUI_WIZ_IMPORT_NO_CHANGE_DEST_STORE)
4510             EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_SPECIFY_STORE), FALSE);
4511         EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_STORE), FALSE);
4512         EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_BROWSE_STORE), FALSE);
4513         break;
4514     }
4515     case WM_NOTIFY:
4516     {
4517         NMHDR *hdr = (NMHDR *)lp;
4518
4519         switch (hdr->code)
4520         {
4521         case PSN_SETACTIVE:
4522             PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
4523              PSWIZB_BACK | PSWIZB_NEXT);
4524             ret = TRUE;
4525             break;
4526         case PSN_WIZNEXT:
4527         {
4528             data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
4529             if (IsDlgButtonChecked(hwnd, IDC_IMPORT_SPECIFY_STORE) &&
4530              !data->hDestCertStore)
4531             {
4532                 import_warning(data->dwFlags, hwnd, data->pwszWizardTitle,
4533                  IDS_IMPORT_SELECT_STORE);
4534                 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
4535                 ret = 1;
4536             }
4537             break;
4538         }
4539         }
4540         break;
4541     }
4542     case WM_COMMAND:
4543         switch (wp)
4544         {
4545         case IDC_IMPORT_AUTO_STORE:
4546             data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
4547             data->autoDest = TRUE;
4548             EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_STORE), FALSE);
4549             EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_BROWSE_STORE), FALSE);
4550             break;
4551         case IDC_IMPORT_SPECIFY_STORE:
4552             data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
4553             data->autoDest = FALSE;
4554             EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_STORE), TRUE);
4555             EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_BROWSE_STORE), TRUE);
4556             break;
4557         case IDC_IMPORT_BROWSE_STORE:
4558         {
4559             CRYPTUI_ENUM_SYSTEM_STORE_ARGS enumArgs = {
4560              CERT_SYSTEM_STORE_CURRENT_USER, NULL };
4561             CRYPTUI_ENUM_DATA enumData = { 0, NULL, 1, &enumArgs };
4562             CRYPTUI_SELECTSTORE_INFO_W selectInfo;
4563             HCERTSTORE store;
4564
4565             data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
4566             selectInfo.dwSize = sizeof(selectInfo);
4567             selectInfo.parent = hwnd;
4568             selectInfo.dwFlags = CRYPTUI_ENABLE_SHOW_PHYSICAL_STORE;
4569             selectInfo.pwszTitle = selectInfo.pwszTitle = NULL;
4570             selectInfo.pEnumData = &enumData;
4571             selectInfo.pfnSelectedStoreCallback = NULL;
4572             if ((store = CryptUIDlgSelectStoreW(&selectInfo)))
4573             {
4574                 WCHAR storeTitle[MAX_STRING_LEN];
4575
4576                 LoadStringW(hInstance, IDS_IMPORT_DEST_DETERMINED,
4577                  storeTitle, sizeof(storeTitle) / sizeof(storeTitle[0]));
4578                 SendMessageW(GetDlgItem(hwnd, IDC_IMPORT_STORE), WM_SETTEXT,
4579                  0, (LPARAM)storeTitle);
4580                 data->hDestCertStore = store;
4581                 data->freeDest = TRUE;
4582             }
4583             break;
4584         }
4585         }
4586         break;
4587     }
4588     return ret;
4589 }
4590
4591 static void show_import_details(HWND lv, struct ImportWizData *data)
4592 {
4593     WCHAR text[MAX_STRING_LEN];
4594     LVITEMW item;
4595     int contentID;
4596
4597     item.mask = LVIF_TEXT;
4598     item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
4599     item.iSubItem = 0;
4600     LoadStringW(hInstance, IDS_IMPORT_STORE_SELECTION, text,
4601      sizeof(text)/ sizeof(text[0]));
4602     item.pszText = text;
4603     SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
4604     item.iSubItem = 1;
4605     if (data->autoDest)
4606         LoadStringW(hInstance, IDS_IMPORT_DEST_AUTOMATIC, text,
4607          sizeof(text)/ sizeof(text[0]));
4608     else
4609         LoadStringW(hInstance, IDS_IMPORT_DEST_DETERMINED, text,
4610          sizeof(text)/ sizeof(text[0]));
4611     SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
4612     item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
4613     item.iSubItem = 0;
4614     LoadStringW(hInstance, IDS_IMPORT_CONTENT, text,
4615      sizeof(text)/ sizeof(text[0]));
4616     SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
4617     switch (data->contentType)
4618     {
4619     case CERT_QUERY_CONTENT_CERT:
4620     case CERT_QUERY_CONTENT_SERIALIZED_CERT:
4621         contentID = IDS_IMPORT_CONTENT_CERT;
4622         break;
4623     case CERT_QUERY_CONTENT_CRL:
4624     case CERT_QUERY_CONTENT_SERIALIZED_CRL:
4625         contentID = IDS_IMPORT_CONTENT_CRL;
4626         break;
4627     case CERT_QUERY_CONTENT_CTL:
4628     case CERT_QUERY_CONTENT_SERIALIZED_CTL:
4629         contentID = IDS_IMPORT_CONTENT_CTL;
4630         break;
4631     case CERT_QUERY_CONTENT_PKCS7_SIGNED:
4632         contentID = IDS_IMPORT_CONTENT_CMS;
4633         break;
4634     case CERT_QUERY_CONTENT_FLAG_PFX:
4635         contentID = IDS_IMPORT_CONTENT_PFX;
4636         break;
4637     default:
4638         contentID = IDS_IMPORT_CONTENT_STORE;
4639         break;
4640     }
4641     LoadStringW(hInstance, contentID, text, sizeof(text)/ sizeof(text[0]));
4642     item.iSubItem = 1;
4643     SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
4644     if (data->fileName)
4645     {
4646         item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
4647         item.iSubItem = 0;
4648         LoadStringW(hInstance, IDS_IMPORT_FILE, text,
4649          sizeof(text)/ sizeof(text[0]));
4650         SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
4651         item.iSubItem = 1;
4652         item.pszText = data->fileName;
4653         SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
4654     }
4655 }
4656
4657 static BOOL do_import(DWORD dwFlags, HWND hwndParent, LPCWSTR pwszWizardTitle,
4658  PCCRYPTUI_WIZ_IMPORT_SRC_INFO pImportSrc, HCERTSTORE hDestCertStore)
4659 {
4660     BOOL ret;
4661
4662     switch (pImportSrc->dwSubjectChoice)
4663     {
4664     case CRYPTUI_WIZ_IMPORT_SUBJECT_FILE:
4665         ret = import_file(dwFlags, hwndParent, pwszWizardTitle,
4666          pImportSrc->u.pwszFileName, hDestCertStore);
4667         break;
4668     case CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_CONTEXT:
4669         if ((ret = check_context_type(dwFlags, CERT_QUERY_CONTENT_CERT)))
4670             ret = import_cert(pImportSrc->u.pCertContext, hDestCertStore);
4671         else
4672             import_warn_type_mismatch(dwFlags, hwndParent, pwszWizardTitle);
4673         break;
4674     case CRYPTUI_WIZ_IMPORT_SUBJECT_CRL_CONTEXT:
4675         if ((ret = check_context_type(dwFlags, CERT_QUERY_CONTENT_CRL)))
4676             ret = import_crl(pImportSrc->u.pCRLContext, hDestCertStore);
4677         else
4678             import_warn_type_mismatch(dwFlags, hwndParent, pwszWizardTitle);
4679         break;
4680     case CRYPTUI_WIZ_IMPORT_SUBJECT_CTL_CONTEXT:
4681         if ((ret = check_context_type(dwFlags, CERT_QUERY_CONTENT_CTL)))
4682             ret = import_ctl(pImportSrc->u.pCTLContext, hDestCertStore);
4683         else
4684             import_warn_type_mismatch(dwFlags, hwndParent, pwszWizardTitle);
4685         break;
4686     case CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_STORE:
4687         ret = import_store(dwFlags, hwndParent, pwszWizardTitle,
4688          pImportSrc->u.hCertStore, hDestCertStore);
4689         break;
4690     default:
4691         WARN("unknown source type: %u\n", pImportSrc->dwSubjectChoice);
4692         SetLastError(E_INVALIDARG);
4693         ret = FALSE;
4694     }
4695     return ret;
4696 }
4697
4698 static LRESULT CALLBACK import_finish_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
4699  LPARAM lp)
4700 {
4701     LRESULT ret = 0;
4702     struct ImportWizData *data;
4703
4704     switch (msg)
4705     {
4706     case WM_INITDIALOG:
4707     {
4708         PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
4709         HWND lv = GetDlgItem(hwnd, IDC_IMPORT_SETTINGS);
4710         RECT rc;
4711         LVCOLUMNW column;
4712
4713         data = (struct ImportWizData *)page->lParam;
4714         SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
4715         SendMessageW(GetDlgItem(hwnd, IDC_IMPORT_TITLE), WM_SETFONT,
4716          (WPARAM)data->titleFont, TRUE);
4717         GetWindowRect(lv, &rc);
4718         column.mask = LVCF_WIDTH;
4719         column.cx = (rc.right - rc.left) / 2 - 2;
4720         SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
4721         SendMessageW(lv, LVM_INSERTCOLUMNW, 1, (LPARAM)&column);
4722         show_import_details(lv, data);
4723         break;
4724     }
4725     case WM_NOTIFY:
4726     {
4727         NMHDR *hdr = (NMHDR *)lp;
4728
4729         switch (hdr->code)
4730         {
4731         case PSN_SETACTIVE:
4732         {
4733             HWND lv = GetDlgItem(hwnd, IDC_IMPORT_SETTINGS);
4734
4735             data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
4736             SendMessageW(lv, LVM_DELETEALLITEMS, 0, 0);
4737             show_import_details(lv, data);
4738             PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
4739              PSWIZB_BACK | PSWIZB_FINISH);
4740             ret = TRUE;
4741             break;
4742         }
4743         case PSN_WIZFINISH:
4744         {
4745             data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
4746             if ((data->success = do_import(data->dwFlags, hwnd,
4747              data->pwszWizardTitle, &data->importSrc, data->hDestCertStore)))
4748             {
4749                 WCHAR title[MAX_STRING_LEN], message[MAX_STRING_LEN];
4750                 LPCWSTR pTitle;
4751
4752                 if (data->pwszWizardTitle)
4753                     pTitle = data->pwszWizardTitle;
4754                 else
4755                 {
4756                     LoadStringW(hInstance, IDS_IMPORT_WIZARD, title,
4757                      sizeof(title) / sizeof(title[0]));
4758                     pTitle = title;
4759                 }
4760                 LoadStringW(hInstance, IDS_IMPORT_SUCCEEDED, message,
4761                  sizeof(message) / sizeof(message[0]));
4762                 MessageBoxW(hwnd, message, pTitle, MB_OK);
4763             }
4764             else
4765                 import_warning(data->dwFlags, hwnd, data->pwszWizardTitle,
4766                  IDS_IMPORT_SUCCEEDED);
4767             break;
4768         }
4769         }
4770         break;
4771     }
4772     }
4773     return ret;
4774 }
4775
4776 static BOOL show_import_ui(DWORD dwFlags, HWND hwndParent,
4777  LPCWSTR pwszWizardTitle, PCCRYPTUI_WIZ_IMPORT_SRC_INFO pImportSrc,
4778  HCERTSTORE hDestCertStore)
4779 {
4780     PROPSHEETHEADERW hdr;
4781     PROPSHEETPAGEW pages[4];
4782     struct ImportWizData data;
4783     int nPages = 0;
4784
4785     data.dwFlags = dwFlags;
4786     data.pwszWizardTitle = pwszWizardTitle;
4787     if (pImportSrc)
4788         memcpy(&data.importSrc, pImportSrc, sizeof(data.importSrc));
4789     else
4790         memset(&data.importSrc, 0, sizeof(data.importSrc));
4791     data.fileName = NULL;
4792     data.freeSource = FALSE;
4793     data.hDestCertStore = hDestCertStore;
4794     data.freeDest = FALSE;
4795     data.autoDest = TRUE;
4796     data.success = TRUE;
4797
4798     memset(&pages, 0, sizeof(pages));
4799
4800     pages[nPages].dwSize = sizeof(pages[0]);
4801     pages[nPages].hInstance = hInstance;
4802     pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_IMPORT_WELCOME);
4803     pages[nPages].pfnDlgProc = import_welcome_dlg_proc;
4804     pages[nPages].dwFlags = PSP_HIDEHEADER;
4805     pages[nPages].lParam = (LPARAM)&data;
4806     nPages++;
4807
4808     if (!pImportSrc ||
4809      pImportSrc->dwSubjectChoice == CRYPTUI_WIZ_IMPORT_SUBJECT_FILE)
4810     {
4811         pages[nPages].dwSize = sizeof(pages[0]);
4812         pages[nPages].hInstance = hInstance;
4813         pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_IMPORT_FILE);
4814         pages[nPages].pfnDlgProc = import_file_dlg_proc;
4815         pages[nPages].dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
4816         pages[nPages].pszHeaderTitle = MAKEINTRESOURCEW(IDS_IMPORT_FILE_TITLE);
4817         pages[nPages].pszHeaderSubTitle =
4818          MAKEINTRESOURCEW(IDS_IMPORT_FILE_SUBTITLE);
4819         pages[nPages].lParam = (LPARAM)&data;
4820         nPages++;
4821     }
4822     else
4823     {
4824         switch (pImportSrc->dwSubjectChoice)
4825         {
4826         case CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_CONTEXT:
4827             data.contentType = CERT_QUERY_CONTENT_CERT;
4828             break;
4829         case CRYPTUI_WIZ_IMPORT_SUBJECT_CRL_CONTEXT:
4830             data.contentType = CERT_QUERY_CONTENT_CRL;
4831             break;
4832         case CRYPTUI_WIZ_IMPORT_SUBJECT_CTL_CONTEXT:
4833             data.contentType = CERT_QUERY_CONTENT_CTL;
4834             break;
4835         case CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_STORE:
4836             data.contentType = CERT_QUERY_CONTENT_SERIALIZED_STORE;
4837             break;
4838         }
4839     }
4840
4841     pages[nPages].dwSize = sizeof(pages[0]);
4842     pages[nPages].hInstance = hInstance;
4843     pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_IMPORT_STORE);
4844     pages[nPages].pfnDlgProc = import_store_dlg_proc;
4845     pages[nPages].dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
4846     pages[nPages].pszHeaderTitle = MAKEINTRESOURCEW(IDS_IMPORT_STORE_TITLE);
4847     pages[nPages].pszHeaderSubTitle =
4848      MAKEINTRESOURCEW(IDS_IMPORT_STORE_SUBTITLE);
4849     pages[nPages].lParam = (LPARAM)&data;
4850     nPages++;
4851
4852     pages[nPages].dwSize = sizeof(pages[0]);
4853     pages[nPages].hInstance = hInstance;
4854     pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_IMPORT_FINISH);
4855     pages[nPages].pfnDlgProc = import_finish_dlg_proc;
4856     pages[nPages].dwFlags = PSP_HIDEHEADER;
4857     pages[nPages].lParam = (LPARAM)&data;
4858     nPages++;
4859
4860     memset(&hdr, 0, sizeof(hdr));
4861     hdr.dwSize = sizeof(hdr);
4862     hdr.hwndParent = hwndParent;
4863     hdr.dwFlags = PSH_PROPSHEETPAGE | PSH_WIZARD97_NEW | PSH_HEADER |
4864      PSH_WATERMARK;
4865     hdr.hInstance = hInstance;
4866     if (pwszWizardTitle)
4867         hdr.pszCaption = pwszWizardTitle;
4868     else
4869         hdr.pszCaption = MAKEINTRESOURCEW(IDS_IMPORT_WIZARD);
4870     hdr.u3.ppsp = pages;
4871     hdr.nPages = nPages;
4872     hdr.u4.pszbmWatermark = MAKEINTRESOURCEW(IDB_CERT_WATERMARK);
4873     hdr.u5.pszbmHeader = MAKEINTRESOURCEW(IDB_CERT_HEADER);
4874     PropertySheetW(&hdr);
4875     HeapFree(GetProcessHeap(), 0, data.fileName);
4876     if (data.freeSource &&
4877      data.importSrc.dwSubjectChoice == CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_STORE)
4878         CertCloseStore(data.importSrc.u.hCertStore, 0);
4879     DeleteObject(data.titleFont);
4880     return data.success;
4881 }
4882
4883 BOOL WINAPI CryptUIWizImport(DWORD dwFlags, HWND hwndParent, LPCWSTR pwszWizardTitle,
4884                              PCCRYPTUI_WIZ_IMPORT_SRC_INFO pImportSrc, HCERTSTORE hDestCertStore)
4885 {
4886     BOOL ret;
4887
4888     TRACE("(0x%08x, %p, %s, %p, %p)\n", dwFlags, hwndParent, debugstr_w(pwszWizardTitle),
4889           pImportSrc, hDestCertStore);
4890
4891     if (pImportSrc &&
4892      pImportSrc->dwSize != sizeof(CRYPTUI_WIZ_IMPORT_SRC_INFO))
4893     {
4894         SetLastError(E_INVALIDARG);
4895         return FALSE;
4896     }
4897
4898     if (!(dwFlags & CRYPTUI_WIZ_NO_UI))
4899         ret = show_import_ui(dwFlags, hwndParent, pwszWizardTitle, pImportSrc,
4900          hDestCertStore);
4901     else if (pImportSrc)
4902         ret = do_import(dwFlags, hwndParent, pwszWizardTitle, pImportSrc,
4903          hDestCertStore);
4904     else
4905     {
4906         /* Can't have no UI without specifying source */
4907         SetLastError(E_INVALIDARG);
4908         ret = FALSE;
4909     }
4910
4911     return ret;
4912 }