dlls/crypt32/str.c

   1 /*
   2  * Copyright 2006 Juan Lang for CodeWeavers
   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 #include <stdarg.h>
  19
  20 #define NONAMELESSUNION
  21
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "winnls.h"
  25 #include "winuser.h"
  26 #include "wincrypt.h"
  27 #include "wine/debug.h"
  28 #include "crypt32_private.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
  31
  32 DWORD WINAPI CertRDNValueToStrA(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue,
  33  LPSTR psz, DWORD csz)
  34 {
  35     DWORD ret = 0, len;
  36
  37     TRACE("(%d, %p, %p, %d)\n", dwValueType, pValue, psz, csz);
  38
  39     switch (dwValueType)
  40     {
  41     case CERT_RDN_ANY_TYPE:
  42         break;
  43     case CERT_RDN_NUMERIC_STRING:
  44     case CERT_RDN_PRINTABLE_STRING:
  45     case CERT_RDN_TELETEX_STRING:
  46     case CERT_RDN_VIDEOTEX_STRING:
  47     case CERT_RDN_IA5_STRING:
  48     case CERT_RDN_GRAPHIC_STRING:
  49     case CERT_RDN_VISIBLE_STRING:
  50     case CERT_RDN_GENERAL_STRING:
  51         len = pValue->cbData;
  52         if (!psz || !csz)
  53             ret = len;
  54         else
  55         {
  56             DWORD chars = min(len, csz - 1);
  57
  58             if (chars)
  59             {
  60                 memcpy(psz, pValue->pbData, chars);
  61                 ret += chars;
  62                 csz -= chars;
  63             }
  64         }
  65         break;
  66     case CERT_RDN_BMP_STRING:
  67     case CERT_RDN_UTF8_STRING:
  68         len = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)pValue->pbData,
  69          pValue->cbData / sizeof(WCHAR), NULL, 0, NULL, NULL);
  70         if (!psz || !csz)
  71             ret = len;
  72         else
  73         {
  74             DWORD chars = min(pValue->cbData / sizeof(WCHAR), csz - 1);
  75
  76             if (chars)
  77             {
  78                 ret = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)pValue->pbData,
  79                  chars, psz, csz - 1, NULL, NULL);
  80                 csz -= ret;
  81             }
  82         }
  83         break;
  84     default:
  85         FIXME("string type %d unimplemented\n", dwValueType);
  86     }
  87     if (psz && csz)
  88     {
  89         *(psz + ret) = '\0';
  90         csz--;
  91         ret++;
  92     }
  93     else
  94         ret++;
  95     TRACE("returning %d (%s)\n", ret, debugstr_a(psz));
  96     return ret;
  97 }
  98
  99 DWORD WINAPI CertRDNValueToStrW(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue,
 100  LPWSTR psz, DWORD csz)
 101 {
 102     DWORD ret = 0, len, i, strLen;
 103
 104     TRACE("(%d, %p, %p, %d)\n", dwValueType, pValue, psz, csz);
 105
 106     switch (dwValueType)
 107     {
 108     case CERT_RDN_ANY_TYPE:
 109         break;
 110     case CERT_RDN_NUMERIC_STRING:
 111     case CERT_RDN_PRINTABLE_STRING:
 112     case CERT_RDN_TELETEX_STRING:
 113     case CERT_RDN_VIDEOTEX_STRING:
 114     case CERT_RDN_IA5_STRING:
 115     case CERT_RDN_GRAPHIC_STRING:
 116     case CERT_RDN_VISIBLE_STRING:
 117     case CERT_RDN_GENERAL_STRING:
 118         len = pValue->cbData;
 119         if (!psz || !csz)
 120             ret = len;
 121         else
 122         {
 123             WCHAR *ptr = psz;
 124
 125             for (i = 0; i < pValue->cbData && ptr - psz < csz; ptr++, i++)
 126                 *ptr = pValue->pbData[i];
 127             ret = ptr - psz;
 128         }
 129         break;
 130     case CERT_RDN_BMP_STRING:
 131     case CERT_RDN_UTF8_STRING:
 132         strLen = len = pValue->cbData / sizeof(WCHAR);
 133         if (!psz || !csz)
 134             ret = len;
 135         else
 136         {
 137             WCHAR *ptr = psz;
 138
 139             for (i = 0; i < strLen && ptr - psz < csz; ptr++, i++)
 140                 *ptr = ((LPCWSTR)pValue->pbData)[i];
 141             ret = ptr - psz;
 142         }
 143         break;
 144     default:
 145         FIXME("string type %d unimplemented\n", dwValueType);
 146     }
 147     if (psz && csz)
 148     {
 149         *(psz + ret) = '\0';
 150         csz--;
 151         ret++;
 152     }
 153     else
 154         ret++;
 155     TRACE("returning %d (%s)\n", ret, debugstr_w(psz));
 156     return ret;
 157 }
 158
 159 static inline BOOL is_quotable_char(char c)
 160 {
 161     switch(c)
 162     {
 163     case '+':
 164     case ',':
 165     case '"':
 166     case '=':
 167     case '<':
 168     case '>':
 169     case ';':
 170     case '#':
 171     case '\n':
 172         return TRUE;
 173     default:
 174         return FALSE;
 175     }
 176 }
 177
 178 static DWORD quote_rdn_value_to_str_a(DWORD dwValueType,
 179  PCERT_RDN_VALUE_BLOB pValue, LPSTR psz, DWORD csz)
 180 {
 181     DWORD ret = 0, len, i;
 182     BOOL needsQuotes = FALSE;
 183
 184     TRACE("(%d, %p, %p, %d)\n", dwValueType, pValue, psz, csz);
 185
 186     switch (dwValueType)
 187     {
 188     case CERT_RDN_ANY_TYPE:
 189         break;
 190     case CERT_RDN_NUMERIC_STRING:
 191     case CERT_RDN_PRINTABLE_STRING:
 192     case CERT_RDN_TELETEX_STRING:
 193     case CERT_RDN_VIDEOTEX_STRING:
 194     case CERT_RDN_IA5_STRING:
 195     case CERT_RDN_GRAPHIC_STRING:
 196     case CERT_RDN_VISIBLE_STRING:
 197     case CERT_RDN_GENERAL_STRING:
 198         len = pValue->cbData;
 199         if (pValue->cbData && isspace(pValue->pbData[0]))
 200             needsQuotes = TRUE;
 201         if (pValue->cbData && isspace(pValue->pbData[pValue->cbData - 1]))
 202             needsQuotes = TRUE;
 203         for (i = 0; i < pValue->cbData; i++)
 204         {
 205             if (is_quotable_char(pValue->pbData[i]))
 206                 needsQuotes = TRUE;
 207             if (pValue->pbData[i] == '"')
 208                 len += 1;
 209         }
 210         if (needsQuotes)
 211             len += 2;
 212         if (!psz || !csz)
 213             ret = len;
 214         else
 215         {
 216             char *ptr = psz;
 217
 218             if (needsQuotes)
 219                 *ptr++ = '"';
 220             for (i = 0; i < pValue->cbData && ptr - psz < csz; ptr++, i++)
 221             {
 222                 *ptr = pValue->pbData[i];
 223                 if (pValue->pbData[i] == '"' && ptr - psz < csz - 1)
 224                     *(++ptr) = '"';
 225             }
 226             if (needsQuotes && ptr - psz < csz)
 227                 *ptr++ = '"';
 228             ret = ptr - psz;
 229         }
 230         break;
 231     case CERT_RDN_BMP_STRING:
 232     case CERT_RDN_UTF8_STRING:
 233         len = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)pValue->pbData,
 234          pValue->cbData / sizeof(WCHAR), NULL, 0, NULL, NULL);
 235         if (pValue->cbData && iswspace(((LPCWSTR)pValue->pbData)[0]))
 236             needsQuotes = TRUE;
 237         if (pValue->cbData &&
 238          iswspace(((LPCWSTR)pValue->pbData)[pValue->cbData / sizeof(WCHAR)-1]))
 239             needsQuotes = TRUE;
 240         for (i = 0; i < pValue->cbData / sizeof(WCHAR); i++)
 241         {
 242             if (is_quotable_char(((LPCWSTR)pValue->pbData)[i]))
 243                 needsQuotes = TRUE;
 244             if (((LPCWSTR)pValue->pbData)[i] == '"')
 245                 len += 1;
 246         }
 247         if (needsQuotes)
 248             len += 2;
 249         if (!psz || !csz)
 250             ret = len;
 251         else
 252         {
 253             char *dst = psz;
 254
 255             if (needsQuotes)
 256                 *dst++ = '"';
 257             for (i = 0; i < pValue->cbData / sizeof(WCHAR) &&
 258              dst - psz < csz; dst++, i++)
 259             {
 260                 LPCWSTR src = (LPCWSTR)pValue->pbData + i;
 261
 262                 WideCharToMultiByte(CP_ACP, 0, src, 1, dst,
 263                  csz - (dst - psz) - 1, NULL, NULL);
 264                 if (*src == '"' && dst - psz < csz - 1)
 265                     *(++dst) = '"';
 266             }
 267             if (needsQuotes && dst - psz < csz)
 268                 *dst++ = '"';
 269             ret = dst - psz;
 270         }
 271         break;
 272     default:
 273         FIXME("string type %d unimplemented\n", dwValueType);
 274     }
 275     if (psz && csz)
 276     {
 277         *(psz + ret) = '\0';
 278         csz--;
 279         ret++;
 280     }
 281     else
 282         ret++;
 283     TRACE("returning %d (%s)\n", ret, debugstr_a(psz));
 284     return ret;
 285 }
 286
 287 static DWORD quote_rdn_value_to_str_w(DWORD dwValueType,
 288  PCERT_RDN_VALUE_BLOB pValue, LPWSTR psz, DWORD csz)
 289 {
 290     DWORD ret = 0, len, i, strLen;
 291     BOOL needsQuotes = FALSE;
 292
 293     TRACE("(%d, %p, %p, %d)\n", dwValueType, pValue, psz, csz);
 294
 295     switch (dwValueType)
 296     {
 297     case CERT_RDN_ANY_TYPE:
 298         break;
 299     case CERT_RDN_NUMERIC_STRING:
 300     case CERT_RDN_PRINTABLE_STRING:
 301     case CERT_RDN_TELETEX_STRING:
 302     case CERT_RDN_VIDEOTEX_STRING:
 303     case CERT_RDN_IA5_STRING:
 304     case CERT_RDN_GRAPHIC_STRING:
 305     case CERT_RDN_VISIBLE_STRING:
 306     case CERT_RDN_GENERAL_STRING:
 307         len = pValue->cbData;
 308         if (pValue->cbData && isspace(pValue->pbData[0]))
 309             needsQuotes = TRUE;
 310         if (pValue->cbData && isspace(pValue->pbData[pValue->cbData - 1]))
 311             needsQuotes = TRUE;
 312         for (i = 0; i < pValue->cbData; i++)
 313         {
 314             if (is_quotable_char(pValue->pbData[i]))
 315                 needsQuotes = TRUE;
 316             if (pValue->pbData[i] == '"')
 317                 len += 1;
 318         }
 319         if (needsQuotes)
 320             len += 2;
 321         if (!psz || !csz)
 322             ret = len;
 323         else
 324         {
 325             WCHAR *ptr = psz;
 326
 327             if (needsQuotes)
 328                 *ptr++ = '"';
 329             for (i = 0; i < pValue->cbData && ptr - psz < csz; ptr++, i++)
 330             {
 331                 *ptr = pValue->pbData[i];
 332                 if (pValue->pbData[i] == '"' && ptr - psz < csz - 1)
 333                     *(++ptr) = '"';
 334             }
 335             if (needsQuotes && ptr - psz < csz)
 336                 *ptr++ = '"';
 337             ret = ptr - psz;
 338         }
 339         break;
 340     case CERT_RDN_BMP_STRING:
 341     case CERT_RDN_UTF8_STRING:
 342         strLen = len = pValue->cbData / sizeof(WCHAR);
 343         if (pValue->cbData && isspace(pValue->pbData[0]))
 344             needsQuotes = TRUE;
 345         if (pValue->cbData && isspace(pValue->pbData[strLen - 1]))
 346             needsQuotes = TRUE;
 347         for (i = 0; i < strLen; i++)
 348         {
 349             if (is_quotable_char(((LPCWSTR)pValue->pbData)[i]))
 350                 needsQuotes = TRUE;
 351             if (((LPCWSTR)pValue->pbData)[i] == '"')
 352                 len += 1;
 353         }
 354         if (needsQuotes)
 355             len += 2;
 356         if (!psz || !csz)
 357             ret = len;
 358         else
 359         {
 360             WCHAR *ptr = psz;
 361
 362             if (needsQuotes)
 363                 *ptr++ = '"';
 364             for (i = 0; i < strLen && ptr - psz < csz; ptr++, i++)
 365             {
 366                 *ptr = ((LPCWSTR)pValue->pbData)[i];
 367                 if (((LPCWSTR)pValue->pbData)[i] == '"' && ptr - psz < csz - 1)
 368                     *(++ptr) = '"';
 369             }
 370             if (needsQuotes && ptr - psz < csz)
 371                 *ptr++ = '"';
 372             ret = ptr - psz;
 373         }
 374         break;
 375     default:
 376         FIXME("string type %d unimplemented\n", dwValueType);
 377     }
 378     if (psz && csz)
 379     {
 380         *(psz + ret) = '\0';
 381         csz--;
 382         ret++;
 383     }
 384     else
 385         ret++;
 386     TRACE("returning %d (%s)\n", ret, debugstr_w(psz));
 387     return ret;
 388 }
 389
 390 /* Adds the prefix prefix to the string pointed to by psz, followed by the
 391  * character '='.  Copies no more than csz characters.  Returns the number of
 392  * characters copied.  If psz is NULL, returns the number of characters that
 393  * would be copied.
 394  */
 395 static DWORD CRYPT_AddPrefixA(LPCSTR prefix, LPSTR psz, DWORD csz)
 396 {
 397     DWORD chars;
 398
 399     TRACE("(%s, %p, %d)\n", debugstr_a(prefix), psz, csz);
 400
 401     if (psz)
 402     {
 403         chars = min(strlen(prefix), csz);
 404         memcpy(psz, prefix, chars);
 405         *(psz + chars) = '=';
 406         chars++;
 407     }
 408     else
 409         chars = lstrlenA(prefix) + 1;
 410     return chars;
 411 }
 412
 413 DWORD WINAPI CertNameToStrA(DWORD dwCertEncodingType, PCERT_NAME_BLOB pName,
 414  DWORD dwStrType, LPSTR psz, DWORD csz)
 415 {
 416     static const DWORD unsupportedFlags = CERT_NAME_STR_NO_QUOTING_FLAG |
 417      CERT_NAME_STR_ENABLE_T61_UNICODE_FLAG;
 418     static const char commaSep[] = ", ";
 419     static const char semiSep[] = "; ";
 420     static const char crlfSep[] = "\r\n";
 421     static const char plusSep[] = " + ";
 422     static const char spaceSep[] = " ";
 423     DWORD ret = 0, bytes = 0;
 424     BOOL bRet;
 425     CERT_NAME_INFO *info;
 426
 427     TRACE("(%d, %p, %08x, %p, %d)\n", dwCertEncodingType, pName, dwStrType,
 428      psz, csz);
 429     if (dwStrType & unsupportedFlags)
 430         FIXME("unsupported flags: %08x\n", dwStrType & unsupportedFlags);
 431
 432     bRet = CryptDecodeObjectEx(dwCertEncodingType, X509_NAME, pName->pbData,
 433      pName->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &bytes);
 434     if (bRet)
 435     {
 436         DWORD i, j, sepLen, rdnSepLen;
 437         LPCSTR sep, rdnSep;
 438         BOOL reverse = dwStrType & CERT_NAME_STR_REVERSE_FLAG;
 439         const CERT_RDN *rdn = info->rgRDN;
 440
 441         if(reverse && info->cRDN > 1) rdn += (info->cRDN - 1);
 442
 443         if (dwStrType & CERT_NAME_STR_SEMICOLON_FLAG)
 444             sep = semiSep;
 445         else if (dwStrType & CERT_NAME_STR_CRLF_FLAG)
 446             sep = crlfSep;
 447         else
 448             sep = commaSep;
 449         sepLen = strlen(sep);
 450         if (dwStrType & CERT_NAME_STR_NO_PLUS_FLAG)
 451             rdnSep = spaceSep;
 452         else
 453             rdnSep = plusSep;
 454         rdnSepLen = strlen(rdnSep);
 455         for (i = 0; (!psz || ret < csz) && i < info->cRDN; i++)
 456         {
 457             for (j = 0; (!psz || ret < csz) && j < rdn->cRDNAttr; j++)
 458             {
 459                 DWORD chars;
 460                 char prefixBuf[13]; /* big enough for SERIALNUMBER */
 461                 LPCSTR prefix = NULL;
 462
 463                 if ((dwStrType & 0x000000ff) == CERT_OID_NAME_STR)
 464                     prefix = rdn->rgRDNAttr[j].pszObjId;
 465                 else if ((dwStrType & 0x000000ff) == CERT_X500_NAME_STR)
 466                 {
 467                     PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(
 468                      CRYPT_OID_INFO_OID_KEY,
 469                      rdn->rgRDNAttr[j].pszObjId,
 470                      CRYPT_RDN_ATTR_OID_GROUP_ID);
 471
 472                     if (oidInfo)
 473                     {
 474                         WideCharToMultiByte(CP_ACP, 0, oidInfo->pwszName, -1,
 475                          prefixBuf, sizeof(prefixBuf), NULL, NULL);
 476                         prefix = prefixBuf;
 477                     }
 478                     else
 479                         prefix = rdn->rgRDNAttr[j].pszObjId;
 480                 }
 481                 if (prefix)
 482                 {
 483                     /* - 1 is needed to account for the NULL terminator. */
 484                     chars = CRYPT_AddPrefixA(prefix,
 485                      psz ? psz + ret : NULL, psz ? csz - ret - 1 : 0);
 486                     ret += chars;
 487                 }
 488                 chars = quote_rdn_value_to_str_a(
 489                  rdn->rgRDNAttr[j].dwValueType,
 490                  &rdn->rgRDNAttr[j].Value, psz ? psz + ret : NULL,
 491                  psz ? csz - ret : 0);
 492                 if (chars)
 493                     ret += chars - 1;
 494                 if (j < rdn->cRDNAttr - 1)
 495                 {
 496                     if (psz && ret < csz - rdnSepLen - 1)
 497                         memcpy(psz + ret, rdnSep, rdnSepLen);
 498                     ret += rdnSepLen;
 499                 }
 500             }
 501             if (i < info->cRDN - 1)
 502             {
 503                 if (psz && ret < csz - sepLen - 1)
 504                     memcpy(psz + ret, sep, sepLen);
 505                 ret += sepLen;
 506             }
 507             if(reverse) rdn--;
 508             else rdn++;
 509         }
 510         LocalFree(info);
 511     }
 512     if (psz && csz)
 513     {
 514         *(psz + ret) = '\0';
 515         ret++;
 516     }
 517     else
 518         ret++;
 519     TRACE("Returning %s\n", debugstr_a(psz));
 520     return ret;
 521 }
 522
 523 /* Adds the prefix prefix to the wide-character string pointed to by psz,
 524  * followed by the character '='.  Copies no more than csz characters.  Returns
 525  * the number of characters copied.  If psz is NULL, returns the number of
 526  * characters that would be copied.
 527  * Assumes the characters in prefix are ASCII (not multibyte characters.)
 528  */
 529 static DWORD CRYPT_AddPrefixAToW(LPCSTR prefix, LPWSTR psz, DWORD csz)
 530 {
 531     DWORD chars;
 532
 533     TRACE("(%s, %p, %d)\n", debugstr_a(prefix), psz, csz);
 534
 535     if (psz)
 536     {
 537         DWORD i;
 538
 539         chars = min(strlen(prefix), csz);
 540         for (i = 0; i < chars; i++)
 541             *(psz + i) = prefix[i];
 542         *(psz + chars) = '=';
 543         chars++;
 544     }
 545     else
 546         chars = lstrlenA(prefix) + 1;
 547     return chars;
 548 }
 549
 550 /* Adds the prefix prefix to the string pointed to by psz, followed by the
 551  * character '='.  Copies no more than csz characters.  Returns the number of
 552  * characters copied.  If psz is NULL, returns the number of characters that
 553  * would be copied.
 554  */
 555 static DWORD CRYPT_AddPrefixW(LPCWSTR prefix, LPWSTR psz, DWORD csz)
 556 {
 557     DWORD chars;
 558
 559     TRACE("(%s, %p, %d)\n", debugstr_w(prefix), psz, csz);
 560
 561     if (psz)
 562     {
 563         chars = min(lstrlenW(prefix), csz);
 564         memcpy(psz, prefix, chars * sizeof(WCHAR));
 565         *(psz + chars) = '=';
 566         chars++;
 567     }
 568     else
 569         chars = lstrlenW(prefix) + 1;
 570     return chars;
 571 }
 572
 573 static const WCHAR indent[] = L"     ";
 574
 575 DWORD cert_name_to_str_with_indent(DWORD dwCertEncodingType, DWORD indentLevel,
 576  const CERT_NAME_BLOB *pName, DWORD dwStrType, LPWSTR psz, DWORD csz)
 577 {
 578     static const DWORD unsupportedFlags = CERT_NAME_STR_NO_QUOTING_FLAG |
 579      CERT_NAME_STR_ENABLE_T61_UNICODE_FLAG;
 580     DWORD ret = 0, bytes = 0;
 581     BOOL bRet;
 582     CERT_NAME_INFO *info;
 583
 584     if (dwStrType & unsupportedFlags)
 585         FIXME("unsupported flags: %08x\n", dwStrType & unsupportedFlags);
 586
 587     bRet = CryptDecodeObjectEx(dwCertEncodingType, X509_NAME, pName->pbData,
 588      pName->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &bytes);
 589     if (bRet)
 590     {
 591         DWORD i, j, sepLen, rdnSepLen;
 592         LPCWSTR sep, rdnSep;
 593         BOOL reverse = dwStrType & CERT_NAME_STR_REVERSE_FLAG;
 594         const CERT_RDN *rdn = info->rgRDN;
 595
 596         if(reverse && info->cRDN > 1) rdn += (info->cRDN - 1);
 597
 598         if (dwStrType & CERT_NAME_STR_SEMICOLON_FLAG)
 599             sep = L"; ";
 600         else if (dwStrType & CERT_NAME_STR_CRLF_FLAG)
 601             sep = L"\r\n";
 602         else
 603             sep = L", ";
 604         sepLen = lstrlenW(sep);
 605         if (dwStrType & CERT_NAME_STR_NO_PLUS_FLAG)
 606             rdnSep = L" ";
 607         else
 608             rdnSep = L" + ";
 609         rdnSepLen = lstrlenW(rdnSep);
 610         for (i = 0; (!psz || ret < csz) && i < info->cRDN; i++)
 611         {
 612             for (j = 0; (!psz || ret < csz) && j < rdn->cRDNAttr; j++)
 613             {
 614                 DWORD chars;
 615                 LPCSTR prefixA = NULL;
 616                 LPCWSTR prefixW = NULL;
 617
 618                 if ((dwStrType & 0x000000ff) == CERT_OID_NAME_STR)
 619                     prefixA = rdn->rgRDNAttr[j].pszObjId;
 620                 else if ((dwStrType & 0x000000ff) == CERT_X500_NAME_STR)
 621                 {
 622                     PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(
 623                      CRYPT_OID_INFO_OID_KEY,
 624                      rdn->rgRDNAttr[j].pszObjId,
 625                      CRYPT_RDN_ATTR_OID_GROUP_ID);
 626
 627                     if (oidInfo)
 628                         prefixW = oidInfo->pwszName;
 629                     else
 630                         prefixA = rdn->rgRDNAttr[j].pszObjId;
 631                 }
 632                 if (dwStrType & CERT_NAME_STR_CRLF_FLAG)
 633                 {
 634                     DWORD k;
 635
 636                     for (k = 0; k < indentLevel; k++)
 637                     {
 638                         if (psz)
 639                         {
 640                             chars = min(lstrlenW(indent), csz - ret - 1);
 641                             memcpy(psz + ret, indent, chars * sizeof(WCHAR));
 642                         }
 643                         else
 644                             chars = lstrlenW(indent);
 645                         ret += chars;
 646                     }
 647                 }
 648                 if (prefixW)
 649                 {
 650                     /* - 1 is needed to account for the NULL terminator. */
 651                     chars = CRYPT_AddPrefixW(prefixW,
 652                      psz ? psz + ret : NULL, psz ? csz - ret - 1 : 0);
 653                     ret += chars;
 654                 }
 655                 else if (prefixA)
 656                 {
 657                     /* - 1 is needed to account for the NULL terminator. */
 658                     chars = CRYPT_AddPrefixAToW(prefixA,
 659                      psz ? psz + ret : NULL, psz ? csz - ret - 1 : 0);
 660                     ret += chars;
 661                 }
 662                 chars = quote_rdn_value_to_str_w(
 663                  rdn->rgRDNAttr[j].dwValueType,
 664                  &rdn->rgRDNAttr[j].Value, psz ? psz + ret : NULL,
 665                  psz ? csz - ret : 0);
 666                 if (chars)
 667                     ret += chars - 1;
 668                 if (j < rdn->cRDNAttr - 1)
 669                 {
 670                     if (psz && ret < csz - rdnSepLen - 1)
 671                         memcpy(psz + ret, rdnSep, rdnSepLen * sizeof(WCHAR));
 672                     ret += rdnSepLen;
 673                 }
 674             }
 675             if (i < info->cRDN - 1)
 676             {
 677                 if (psz && ret < csz - sepLen - 1)
 678                     memcpy(psz + ret, sep, sepLen * sizeof(WCHAR));
 679                 ret += sepLen;
 680             }
 681             if(reverse) rdn--;
 682             else rdn++;
 683         }
 684         LocalFree(info);
 685     }
 686     if (psz && csz)
 687     {
 688         *(psz + ret) = '\0';
 689         ret++;
 690     }
 691     else
 692         ret++;
 693     return ret;
 694 }
 695
 696 DWORD WINAPI CertNameToStrW(DWORD dwCertEncodingType, PCERT_NAME_BLOB pName,
 697  DWORD dwStrType, LPWSTR psz, DWORD csz)
 698 {
 699     BOOL ret;
 700
 701     TRACE("(%d, %p, %08x, %p, %d)\n", dwCertEncodingType, pName, dwStrType,
 702      psz, csz);
 703
 704     ret = cert_name_to_str_with_indent(dwCertEncodingType, 0, pName, dwStrType,
 705      psz, csz);
 706     TRACE("Returning %s\n", debugstr_w(psz));
 707     return ret;
 708 }
 709
 710 BOOL WINAPI CertStrToNameA(DWORD dwCertEncodingType, LPCSTR pszX500,
 711  DWORD dwStrType, void *pvReserved, BYTE *pbEncoded, DWORD *pcbEncoded,
 712  LPCSTR *ppszError)
 713 {
 714     BOOL ret;
 715     int len;
 716
 717     TRACE("(%08x, %s, %08x, %p, %p, %p, %p)\n", dwCertEncodingType,
 718      debugstr_a(pszX500), dwStrType, pvReserved, pbEncoded, pcbEncoded,
 719      ppszError);
 720
 721     len = MultiByteToWideChar(CP_ACP, 0, pszX500, -1, NULL, 0);
 722     if (len)
 723     {
 724         LPWSTR x500, errorStr;
 725
 726         if ((x500 = CryptMemAlloc(len * sizeof(WCHAR))))
 727         {
 728             MultiByteToWideChar(CP_ACP, 0, pszX500, -1, x500, len);
 729             ret = CertStrToNameW(dwCertEncodingType, x500, dwStrType,
 730              pvReserved, pbEncoded, pcbEncoded,
 731              ppszError ? (LPCWSTR *)&errorStr : NULL);
 732             if (ppszError)
 733             {
 734                 if (!ret)
 735                 {
 736                     LONG i;
 737
 738                     *ppszError = pszX500;
 739                     for (i = 0; i < errorStr - x500; i++)
 740                         *ppszError = CharNextA(*ppszError);
 741                 }
 742                 else
 743                     *ppszError = NULL;
 744             }
 745             CryptMemFree(x500);
 746         }
 747         else
 748         {
 749             SetLastError(ERROR_OUTOFMEMORY);
 750             ret = FALSE;
 751         }
 752     }
 753     else
 754     {
 755         SetLastError(CRYPT_E_INVALID_X500_STRING);
 756         if (ppszError)
 757             *ppszError = pszX500;
 758         ret = FALSE;
 759     }
 760     return ret;
 761 }
 762
 763 struct KeynameKeeper
 764 {
 765     WCHAR  buf[10]; /* big enough for L"GivenName" */
 766     LPWSTR keyName; /* usually = buf, but may be allocated */
 767     DWORD  keyLen;  /* full available buffer size in WCHARs */
 768 };
 769
 770 static void CRYPT_InitializeKeynameKeeper(struct KeynameKeeper *keeper)
 771 {
 772     keeper->keyName = keeper->buf;
 773     keeper->keyLen = ARRAY_SIZE(keeper->buf);
 774 }
 775
 776 static void CRYPT_FreeKeynameKeeper(struct KeynameKeeper *keeper)
 777 {
 778     if (keeper->keyName != keeper->buf)
 779         CryptMemFree(keeper->keyName);
 780 }
 781
 782 struct X500TokenW
 783 {
 784     LPCWSTR start;
 785     LPCWSTR end;
 786 };
 787
 788 static void CRYPT_KeynameKeeperFromTokenW(struct KeynameKeeper *keeper,
 789  const struct X500TokenW *key)
 790 {
 791     DWORD len = key->end - key->start;
 792
 793     if (len >= keeper->keyLen)
 794     {
 795         CRYPT_FreeKeynameKeeper( keeper );
 796         keeper->keyLen = len + 1;
 797         keeper->keyName = CryptMemAlloc(keeper->keyLen * sizeof(WCHAR));
 798     }
 799     memcpy(keeper->keyName, key->start, len * sizeof(WCHAR));
 800     keeper->keyName[len] = '\0';
 801     TRACE("Keyname is %s\n", debugstr_w(keeper->keyName));
 802 }
 803
 804 static BOOL CRYPT_GetNextKeyW(LPCWSTR str, struct X500TokenW *token,
 805  LPCWSTR *ppszError)
 806 {
 807     BOOL ret = TRUE;
 808
 809     while (*str && iswspace(*str))
 810         str++;
 811     if (*str)
 812     {
 813         token->start = str;
 814         while (*str && *str != '=' && !iswspace(*str))
 815             str++;
 816         if (*str && (*str == '=' || iswspace(*str)))
 817             token->end = str;
 818         else
 819         {
 820             TRACE("missing equals char at %s\n", debugstr_w(token->start));
 821             if (ppszError)
 822                 *ppszError = token->start;
 823             SetLastError(CRYPT_E_INVALID_X500_STRING);
 824             ret = FALSE;
 825         }
 826     }
 827     else
 828         token->start = NULL;
 829     return ret;
 830 }
 831
 832 /* Assumes separators are characters in the 0-255 range */
 833 static BOOL CRYPT_GetNextValueW(LPCWSTR str, DWORD dwFlags, LPCWSTR separators,
 834  WCHAR *separator_used, struct X500TokenW *token, LPCWSTR *ppszError)
 835 {
 836     BOOL ret = TRUE;
 837
 838     TRACE("(%s, %s, %p, %p)\n", debugstr_w(str), debugstr_w(separators), token,
 839      ppszError);
 840
 841     *separator_used = 0;
 842     while (*str && iswspace(*str))
 843         str++;
 844     if (*str)
 845     {
 846         token->start = str;
 847         if (!(dwFlags & CERT_NAME_STR_NO_QUOTING_FLAG) && *str == '"')
 848         {
 849             token->end = NULL;
 850             str++;
 851             while (!token->end && ret)
 852             {
 853                 while (*str && *str != '"')
 854                     str++;
 855                 if (*str == '"')
 856                 {
 857                     if (*(str + 1) != '"')
 858                         token->end = str + 1;
 859                     else
 860                         str += 2;
 861                 }
 862                 else
 863                 {
 864                     TRACE("unterminated quote at %s\n", debugstr_w(str));
 865                     if (ppszError)
 866                         *ppszError = str;
 867                     SetLastError(CRYPT_E_INVALID_X500_STRING);
 868                     ret = FALSE;
 869                 }
 870             }
 871         }
 872         else
 873         {
 874             WCHAR map[256] = { 0 };
 875
 876             while (*separators)
 877                 map[*separators++] = 1;
 878             while (*str && (*str >= 0xff || !map[*str]))
 879                 str++;
 880             token->end = str;
 881             if (map[*str]) *separator_used = *str;
 882         }
 883     }
 884     else
 885     {
 886         TRACE("missing value at %s\n", debugstr_w(str));
 887         if (ppszError)
 888             *ppszError = str;
 889         SetLastError(CRYPT_E_INVALID_X500_STRING);
 890         ret = FALSE;
 891     }
 892     return ret;
 893 }
 894
 895 /* Encodes the string represented by value as the string type type into the
 896  * CERT_NAME_BLOB output.  If there is an error and ppszError is not NULL,
 897  * *ppszError is set to the first failing character.  If there is no error,
 898  * output's pbData must be freed with LocalFree.
 899  */
 900 static BOOL CRYPT_EncodeValueWithType(DWORD dwCertEncodingType,
 901  const struct X500TokenW *value, PCERT_NAME_BLOB output, DWORD type,
 902  LPCWSTR *ppszError)
 903 {
 904     CERT_NAME_VALUE nameValue = { type, { 0, NULL } };
 905     BOOL ret = TRUE;
 906
 907     if (value->end > value->start)
 908     {
 909         LONG i;
 910         LPWSTR ptr;
 911
 912         nameValue.Value.pbData = CryptMemAlloc((value->end - value->start + 1) *
 913          sizeof(WCHAR));
 914         if (!nameValue.Value.pbData)
 915         {
 916             SetLastError(ERROR_OUTOFMEMORY);
 917             return FALSE;
 918         }
 919         ptr = (LPWSTR)nameValue.Value.pbData;
 920         for (i = 0; i < value->end - value->start; i++)
 921         {
 922             *ptr++ = value->start[i];
 923             if (value->start[i] == '"')
 924                 i++;
 925         }
 926         /* The string is NULL terminated because of a quirk in encoding
 927          * unicode names values:  if the length is given as 0, the value is
 928          * assumed to be a NULL-terminated string.
 929          */
 930         *ptr = 0;
 931         nameValue.Value.cbData = (LPBYTE)ptr - nameValue.Value.pbData;
 932     }
 933     ret = CryptEncodeObjectEx(dwCertEncodingType, X509_UNICODE_NAME_VALUE,
 934      &nameValue, CRYPT_ENCODE_ALLOC_FLAG, NULL, &output->pbData,
 935      &output->cbData);
 936     if (!ret && ppszError)
 937     {
 938         if (type == CERT_RDN_NUMERIC_STRING &&
 939          GetLastError() == CRYPT_E_INVALID_NUMERIC_STRING)
 940             *ppszError = value->start + output->cbData;
 941         else if (type == CERT_RDN_PRINTABLE_STRING &&
 942          GetLastError() == CRYPT_E_INVALID_PRINTABLE_STRING)
 943             *ppszError = value->start + output->cbData;
 944         else if (type == CERT_RDN_IA5_STRING &&
 945          GetLastError() == CRYPT_E_INVALID_IA5_STRING)
 946             *ppszError = value->start + output->cbData;
 947     }
 948     CryptMemFree(nameValue.Value.pbData);
 949     return ret;
 950 }
 951
 952 static BOOL CRYPT_EncodeValue(DWORD dwCertEncodingType,
 953  const struct X500TokenW *value, PCERT_NAME_BLOB output, const DWORD *types,
 954  LPCWSTR *ppszError)
 955 {
 956     DWORD i;
 957     BOOL ret;
 958
 959     ret = FALSE;
 960     for (i = 0; !ret && types[i]; i++)
 961         ret = CRYPT_EncodeValueWithType(dwCertEncodingType, value, output,
 962          types[i], ppszError);
 963     return ret;
 964 }
 965
 966 static BOOL CRYPT_ValueToRDN(DWORD dwCertEncodingType, PCERT_NAME_INFO info,
 967  PCCRYPT_OID_INFO keyOID, struct X500TokenW *value, DWORD dwStrType, LPCWSTR *ppszError)
 968 {
 969     BOOL ret = FALSE;
 970
 971     TRACE("OID %s, value %s\n", debugstr_a(keyOID->pszOID),
 972      debugstr_wn(value->start, value->end - value->start));
 973
 974     if (!info->rgRDN)
 975         info->rgRDN = CryptMemAlloc(sizeof(CERT_RDN));
 976     else
 977         info->rgRDN = CryptMemRealloc(info->rgRDN,
 978          (info->cRDN + 1) * sizeof(CERT_RDN));
 979     if (info->rgRDN)
 980     {
 981         /* FIXME: support multiple RDN attrs */
 982         info->rgRDN[info->cRDN].rgRDNAttr =
 983          CryptMemAlloc(sizeof(CERT_RDN_ATTR));
 984         if (info->rgRDN[info->cRDN].rgRDNAttr)
 985         {
 986             static const DWORD defaultTypes[] = { CERT_RDN_PRINTABLE_STRING,
 987              CERT_RDN_BMP_STRING, 0 };
 988             const DWORD *types;
 989
 990             info->rgRDN[info->cRDN].cRDNAttr = 1;
 991             info->rgRDN[info->cRDN].rgRDNAttr[0].pszObjId =
 992              (LPSTR)keyOID->pszOID;
 993             info->rgRDN[info->cRDN].rgRDNAttr[0].dwValueType =
 994              CERT_RDN_ENCODED_BLOB;
 995             if (keyOID->ExtraInfo.cbData)
 996                 types = (const DWORD *)keyOID->ExtraInfo.pbData;
 997             else
 998                 types = defaultTypes;
 999
1000             /* Remove surrounding quotes */
1001             if (value->start[0] == '"' && !(dwStrType & CERT_NAME_STR_NO_QUOTING_FLAG))
1002             {
1003                 value->start++;
1004                 value->end--;
1005             }
1006             ret = CRYPT_EncodeValue(dwCertEncodingType, value,
1007              &info->rgRDN[info->cRDN].rgRDNAttr[0].Value, types, ppszError);
1008         }
1009         else
1010             SetLastError(ERROR_OUTOFMEMORY);
1011         info->cRDN++;
1012     }
1013     else
1014         SetLastError(ERROR_OUTOFMEMORY);
1015     return ret;
1016 }
1017
1018 BOOL WINAPI CertStrToNameW(DWORD dwCertEncodingType, LPCWSTR pszX500,
1019  DWORD dwStrType, void *pvReserved, BYTE *pbEncoded, DWORD *pcbEncoded,
1020  LPCWSTR *ppszError)
1021 {
1022     CERT_NAME_INFO info = { 0, NULL };
1023     LPCWSTR str;
1024     struct KeynameKeeper keeper;
1025     DWORD i;
1026     BOOL ret = TRUE;
1027
1028     TRACE("(%08x, %s, %08x, %p, %p, %p, %p)\n", dwCertEncodingType,
1029      debugstr_w(pszX500), dwStrType, pvReserved, pbEncoded, pcbEncoded,
1030      ppszError);
1031
1032     CRYPT_InitializeKeynameKeeper(&keeper);
1033     str = pszX500;
1034     while (str && *str && ret)
1035     {
1036         struct X500TokenW token;
1037
1038         ret = CRYPT_GetNextKeyW(str, &token, ppszError);
1039         if (ret && token.start)
1040         {
1041             PCCRYPT_OID_INFO keyOID;
1042
1043             CRYPT_KeynameKeeperFromTokenW(&keeper, &token);
1044             keyOID = CryptFindOIDInfo(CRYPT_OID_INFO_NAME_KEY, keeper.keyName,
1045              CRYPT_RDN_ATTR_OID_GROUP_ID);
1046             if (!keyOID)
1047             {
1048                 if (ppszError)
1049                     *ppszError = token.start;
1050                 SetLastError(CRYPT_E_INVALID_X500_STRING);
1051                 ret = FALSE;
1052             }
1053             else
1054             {
1055                 str = token.end;
1056                 while (iswspace(*str))
1057                     str++;
1058                 if (*str != '=')
1059                 {
1060                     if (ppszError)
1061                         *ppszError = str;
1062                     SetLastError(CRYPT_E_INVALID_X500_STRING);
1063                     ret = FALSE;
1064                 }
1065                 else
1066                 {
1067                     LPCWSTR sep;
1068                     WCHAR sep_used;
1069
1070                     str++;
1071                     if (dwStrType & CERT_NAME_STR_COMMA_FLAG)
1072                         sep = L",";
1073                     else if (dwStrType & CERT_NAME_STR_SEMICOLON_FLAG)
1074                         sep = L";";
1075                     else if (dwStrType & CERT_NAME_STR_CRLF_FLAG)
1076                         sep = L"\r\n";
1077                     else if (dwStrType & CERT_NAME_STR_NO_PLUS_FLAG)
1078                         sep = L",;\r\n";
1079                     else
1080                         sep = L"+,;\r\n";
1081                     ret = CRYPT_GetNextValueW(str, dwStrType, sep, &sep_used, &token,
1082                      ppszError);
1083                     if (ret)
1084                     {
1085                         str = token.end;
1086                         /* if token.end points to the separator, skip it */
1087                         if (str && sep_used && *str == sep_used) str++;
1088
1089                         ret = CRYPT_ValueToRDN(dwCertEncodingType, &info,
1090                          keyOID, &token, dwStrType, ppszError);
1091                     }
1092                 }
1093             }
1094         }
1095     }
1096     CRYPT_FreeKeynameKeeper(&keeper);
1097     if (ret)
1098     {
1099         if (ppszError)
1100             *ppszError = NULL;
1101         ret = CryptEncodeObjectEx(dwCertEncodingType, X509_NAME, &info,
1102          0, NULL, pbEncoded, pcbEncoded);
1103     }
1104     for (i = 0; i < info.cRDN; i++)
1105     {
1106         DWORD j;
1107
1108         for (j = 0; j < info.rgRDN[i].cRDNAttr; j++)
1109             LocalFree(info.rgRDN[i].rgRDNAttr[j].Value.pbData);
1110         CryptMemFree(info.rgRDN[i].rgRDNAttr);
1111     }
1112     CryptMemFree(info.rgRDN);
1113     return ret;
1114 }
1115
1116 DWORD WINAPI CertGetNameStringA(PCCERT_CONTEXT pCertContext, DWORD dwType,
1117  DWORD dwFlags, void *pvTypePara, LPSTR pszNameString, DWORD cchNameString)
1118 {
1119     DWORD ret;
1120
1121     TRACE("(%p, %d, %08x, %p, %p, %d)\n", pCertContext, dwType, dwFlags,
1122      pvTypePara, pszNameString, cchNameString);
1123
1124     if (pszNameString)
1125     {
1126         LPWSTR wideName;
1127         DWORD nameLen;
1128
1129         nameLen = CertGetNameStringW(pCertContext, dwType, dwFlags, pvTypePara,
1130          NULL, 0);
1131         wideName = CryptMemAlloc(nameLen * sizeof(WCHAR));
1132         if (wideName)
1133         {
1134             CertGetNameStringW(pCertContext, dwType, dwFlags, pvTypePara,
1135              wideName, nameLen);
1136             nameLen = WideCharToMultiByte(CP_ACP, 0, wideName, nameLen,
1137              pszNameString, cchNameString, NULL, NULL);
1138             if (nameLen <= cchNameString)
1139                 ret = nameLen;
1140             else
1141             {
1142                 pszNameString[cchNameString - 1] = '\0';
1143                 ret = cchNameString;
1144             }
1145             CryptMemFree(wideName);
1146         }
1147         else
1148         {
1149             *pszNameString = '\0';
1150             ret = 1;
1151         }
1152     }
1153     else
1154         ret = CertGetNameStringW(pCertContext, dwType, dwFlags, pvTypePara,
1155          NULL, 0);
1156     return ret;
1157 }
1158
1159 /* Searches cert's extensions for the alternate name extension with OID
1160  * altNameOID, and if found, searches it for the alternate name type entryType.
1161  * If found, returns a pointer to the entry, otherwise returns NULL.
1162  * Regardless of whether an entry of the desired type is found, if the
1163  * alternate name extension is present, sets *info to the decoded alternate
1164  * name extension, which you must free using LocalFree.
1165  * The return value is a pointer within *info, so don't free *info before
1166  * you're done with the return value.
1167  */
1168 static PCERT_ALT_NAME_ENTRY cert_find_alt_name_entry(PCCERT_CONTEXT cert,
1169  LPCSTR altNameOID, DWORD entryType, PCERT_ALT_NAME_INFO *info)
1170 {
1171     PCERT_ALT_NAME_ENTRY entry = NULL;
1172     PCERT_EXTENSION ext = CertFindExtension(altNameOID,
1173      cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
1174
1175     if (ext)
1176     {
1177         DWORD bytes = 0;
1178
1179         if (CryptDecodeObjectEx(cert->dwCertEncodingType, X509_ALTERNATE_NAME,
1180          ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
1181          info, &bytes))
1182         {
1183             DWORD i;
1184
1185             for (i = 0; !entry && i < (*info)->cAltEntry; i++)
1186                 if ((*info)->rgAltEntry[i].dwAltNameChoice == entryType)
1187                     entry = &(*info)->rgAltEntry[i];
1188         }
1189     }
1190     else
1191         *info = NULL;
1192     return entry;
1193 }
1194
1195 static DWORD cert_get_name_from_rdn_attr(DWORD encodingType,
1196  const CERT_NAME_BLOB *name, LPCSTR oid, LPWSTR pszNameString, DWORD cchNameString)
1197 {
1198     CERT_NAME_INFO *nameInfo;
1199     DWORD bytes = 0, ret = 0;
1200
1201     if (CryptDecodeObjectEx(encodingType, X509_NAME, name->pbData,
1202      name->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &nameInfo, &bytes))
1203     {
1204         PCERT_RDN_ATTR nameAttr;
1205
1206         if (!oid)
1207             oid = szOID_RSA_emailAddr;
1208         nameAttr = CertFindRDNAttr(oid, nameInfo);
1209         if (nameAttr)
1210             ret = CertRDNValueToStrW(nameAttr->dwValueType, &nameAttr->Value,
1211              pszNameString, cchNameString);
1212         LocalFree(nameInfo);
1213     }
1214     return ret;
1215 }
1216
1217 DWORD WINAPI CertGetNameStringW(PCCERT_CONTEXT pCertContext, DWORD dwType,
1218  DWORD dwFlags, void *pvTypePara, LPWSTR pszNameString, DWORD cchNameString)
1219 {
1220     DWORD ret = 0;
1221     PCERT_NAME_BLOB name;
1222     LPCSTR altNameOID;
1223
1224     TRACE("(%p, %d, %08x, %p, %p, %d)\n", pCertContext, dwType,
1225      dwFlags, pvTypePara, pszNameString, cchNameString);
1226
1227     if (!pCertContext)
1228         goto done;
1229
1230     if (dwFlags & CERT_NAME_ISSUER_FLAG)
1231     {
1232         name = &pCertContext->pCertInfo->Issuer;
1233         altNameOID = szOID_ISSUER_ALT_NAME;
1234     }
1235     else
1236     {
1237         name = &pCertContext->pCertInfo->Subject;
1238         altNameOID = szOID_SUBJECT_ALT_NAME;
1239     }
1240
1241     switch (dwType)
1242     {
1243     case CERT_NAME_EMAIL_TYPE:
1244     {
1245         CERT_ALT_NAME_INFO *info;
1246         PCERT_ALT_NAME_ENTRY entry = cert_find_alt_name_entry(pCertContext,
1247          altNameOID, CERT_ALT_NAME_RFC822_NAME, &info);
1248
1249         if (entry)
1250         {
1251             if (!pszNameString)
1252                 ret = lstrlenW(entry->u.pwszRfc822Name) + 1;
1253             else if (cchNameString)
1254             {
1255                 ret = min(lstrlenW(entry->u.pwszRfc822Name), cchNameString - 1);
1256                 memcpy(pszNameString, entry->u.pwszRfc822Name,
1257                  ret * sizeof(WCHAR));
1258                 pszNameString[ret++] = 0;
1259             }
1260         }
1261         if (info)
1262             LocalFree(info);
1263         if (!ret)
1264             ret = cert_get_name_from_rdn_attr(pCertContext->dwCertEncodingType,
1265              name, szOID_RSA_emailAddr, pszNameString, cchNameString);
1266         break;
1267     }
1268     case CERT_NAME_RDN_TYPE:
1269     {
1270         DWORD type = pvTypePara ? *(DWORD *)pvTypePara : 0;
1271
1272         if (name->cbData)
1273             ret = CertNameToStrW(pCertContext->dwCertEncodingType, name,
1274              type, pszNameString, cchNameString);
1275         else
1276         {
1277             CERT_ALT_NAME_INFO *info;
1278             PCERT_ALT_NAME_ENTRY entry = cert_find_alt_name_entry(pCertContext,
1279              altNameOID, CERT_ALT_NAME_DIRECTORY_NAME, &info);
1280
1281             if (entry)
1282                 ret = CertNameToStrW(pCertContext->dwCertEncodingType,
1283                  &entry->u.DirectoryName, type, pszNameString, cchNameString);
1284             if (info)
1285                 LocalFree(info);
1286         }
1287         break;
1288     }
1289     case CERT_NAME_ATTR_TYPE:
1290         ret = cert_get_name_from_rdn_attr(pCertContext->dwCertEncodingType,
1291          name, pvTypePara, pszNameString, cchNameString);
1292         if (!ret)
1293         {
1294             CERT_ALT_NAME_INFO *altInfo;
1295             PCERT_ALT_NAME_ENTRY entry = cert_find_alt_name_entry(pCertContext,
1296              altNameOID, CERT_ALT_NAME_DIRECTORY_NAME, &altInfo);
1297
1298             if (entry)
1299                 ret = cert_name_to_str_with_indent(X509_ASN_ENCODING, 0,
1300                  &entry->u.DirectoryName, 0, pszNameString, cchNameString);
1301             if (altInfo)
1302                 LocalFree(altInfo);
1303         }
1304         break;
1305     case CERT_NAME_SIMPLE_DISPLAY_TYPE:
1306     {
1307         static const LPCSTR simpleAttributeOIDs[] = { szOID_COMMON_NAME,
1308          szOID_ORGANIZATIONAL_UNIT_NAME, szOID_ORGANIZATION_NAME,
1309          szOID_RSA_emailAddr };
1310         CERT_NAME_INFO *nameInfo = NULL;
1311         DWORD bytes = 0, i;
1312
1313         if (CryptDecodeObjectEx(pCertContext->dwCertEncodingType, X509_NAME,
1314          name->pbData, name->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &nameInfo,
1315          &bytes))
1316         {
1317             PCERT_RDN_ATTR nameAttr = NULL;
1318
1319             for (i = 0; !nameAttr && i < ARRAY_SIZE(simpleAttributeOIDs); i++)
1320                 nameAttr = CertFindRDNAttr(simpleAttributeOIDs[i], nameInfo);
1321             if (nameAttr)
1322                 ret = CertRDNValueToStrW(nameAttr->dwValueType,
1323                  &nameAttr->Value, pszNameString, cchNameString);
1324             LocalFree(nameInfo);
1325         }
1326         if (!ret)
1327         {
1328             CERT_ALT_NAME_INFO *altInfo;
1329             PCERT_ALT_NAME_ENTRY entry = cert_find_alt_name_entry(pCertContext,
1330              altNameOID, CERT_ALT_NAME_RFC822_NAME, &altInfo);
1331
1332             if (altInfo)
1333             {
1334                 if (!entry && altInfo->cAltEntry)
1335                     entry = &altInfo->rgAltEntry[0];
1336                 if (entry)
1337                 {
1338                     if (!pszNameString)
1339                         ret = lstrlenW(entry->u.pwszRfc822Name) + 1;
1340                     else if (cchNameString)
1341                     {
1342                         ret = min(lstrlenW(entry->u.pwszRfc822Name),
1343                          cchNameString - 1);
1344                         memcpy(pszNameString, entry->u.pwszRfc822Name,
1345                          ret * sizeof(WCHAR));
1346                         pszNameString[ret++] = 0;
1347                     }
1348                 }
1349                 LocalFree(altInfo);
1350             }
1351         }
1352         break;
1353     }
1354     case CERT_NAME_FRIENDLY_DISPLAY_TYPE:
1355     {
1356         DWORD cch = cchNameString;
1357
1358         if (CertGetCertificateContextProperty(pCertContext,
1359          CERT_FRIENDLY_NAME_PROP_ID, pszNameString, &cch))
1360             ret = cch;
1361         else
1362             ret = CertGetNameStringW(pCertContext,
1363              CERT_NAME_SIMPLE_DISPLAY_TYPE, dwFlags, pvTypePara, pszNameString,
1364              cchNameString);
1365         break;
1366     }
1367     case CERT_NAME_DNS_TYPE:
1368     {
1369         CERT_ALT_NAME_INFO *info;
1370         PCERT_ALT_NAME_ENTRY entry = cert_find_alt_name_entry(pCertContext,
1371          altNameOID, CERT_ALT_NAME_DNS_NAME, &info);
1372
1373         if (entry)
1374         {
1375             if (!pszNameString)
1376                 ret = lstrlenW(entry->u.pwszDNSName) + 1;
1377             else if (cchNameString)
1378             {
1379                 ret = min(lstrlenW(entry->u.pwszDNSName), cchNameString - 1);
1380                 memcpy(pszNameString, entry->u.pwszDNSName, ret * sizeof(WCHAR));
1381                 pszNameString[ret++] = 0;
1382             }
1383         }
1384         if (info)
1385             LocalFree(info);
1386         if (!ret)
1387             ret = cert_get_name_from_rdn_attr(pCertContext->dwCertEncodingType,
1388              name, szOID_COMMON_NAME, pszNameString, cchNameString);
1389         break;
1390     }
1391     case CERT_NAME_URL_TYPE:
1392     {
1393         CERT_ALT_NAME_INFO *info;
1394         PCERT_ALT_NAME_ENTRY entry = cert_find_alt_name_entry(pCertContext,
1395          altNameOID, CERT_ALT_NAME_URL, &info);
1396
1397         if (entry)
1398         {
1399             if (!pszNameString)
1400                 ret = lstrlenW(entry->u.pwszURL) + 1;
1401             else if (cchNameString)
1402             {
1403                 ret = min(lstrlenW(entry->u.pwszURL), cchNameString - 1);
1404                 memcpy(pszNameString, entry->u.pwszURL, ret * sizeof(WCHAR));
1405                 pszNameString[ret++] = 0;
1406             }
1407         }
1408         if (info)
1409             LocalFree(info);
1410         break;
1411     }
1412     default:
1413         FIXME("unimplemented for type %d\n", dwType);
1414         ret = 0;
1415     }
1416 done:
1417     if (!ret)
1418     {
1419         if (!pszNameString)
1420             ret = 1;
1421         else if (cchNameString)
1422         {
1423             pszNameString[0] = 0;
1424             ret = 1;
1425         }
1426     }
1427     return ret;
1428 }