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 "wine/unicode.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 && isspaceW(((LPCWSTR)pValue->pbData)[0]))
 236             needsQuotes = TRUE;
 237         if (pValue->cbData &&
 238          isspaceW(((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[10]; /* big enough for GivenName */
 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(strlenW(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[] = { ' ',' ',' ',' ',' ',0 };
 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     static const WCHAR commaSep[] = { ',',' ',0 };
 581     static const WCHAR semiSep[] = { ';',' ',0 };
 582     static const WCHAR crlfSep[] = { '\r','\n',0 };
 583     static const WCHAR plusSep[] = { ' ','+',' ',0 };
 584     static const WCHAR spaceSep[] = { ' ',0 };
 585     DWORD ret = 0, bytes = 0;
 586     BOOL bRet;
 587     CERT_NAME_INFO *info;
 588
 589     if (dwStrType & unsupportedFlags)
 590         FIXME("unsupported flags: %08x\n", dwStrType & unsupportedFlags);
 591
 592     bRet = CryptDecodeObjectEx(dwCertEncodingType, X509_NAME, pName->pbData,
 593      pName->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &bytes);
 594     if (bRet)
 595     {
 596         DWORD i, j, sepLen, rdnSepLen;
 597         LPCWSTR sep, rdnSep;
 598         BOOL reverse = dwStrType & CERT_NAME_STR_REVERSE_FLAG;
 599         const CERT_RDN *rdn = info->rgRDN;
 600
 601         if(reverse && info->cRDN > 1) rdn += (info->cRDN - 1);
 602
 603         if (dwStrType & CERT_NAME_STR_SEMICOLON_FLAG)
 604             sep = semiSep;
 605         else if (dwStrType & CERT_NAME_STR_CRLF_FLAG)
 606             sep = crlfSep;
 607         else
 608             sep = commaSep;
 609         sepLen = lstrlenW(sep);
 610         if (dwStrType & CERT_NAME_STR_NO_PLUS_FLAG)
 611             rdnSep = spaceSep;
 612         else
 613             rdnSep = plusSep;
 614         rdnSepLen = lstrlenW(rdnSep);
 615         for (i = 0; (!psz || ret < csz) && i < info->cRDN; i++)
 616         {
 617             for (j = 0; (!psz || ret < csz) && j < rdn->cRDNAttr; j++)
 618             {
 619                 DWORD chars;
 620                 LPCSTR prefixA = NULL;
 621                 LPCWSTR prefixW = NULL;
 622
 623                 if ((dwStrType & 0x000000ff) == CERT_OID_NAME_STR)
 624                     prefixA = rdn->rgRDNAttr[j].pszObjId;
 625                 else if ((dwStrType & 0x000000ff) == CERT_X500_NAME_STR)
 626                 {
 627                     PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(
 628                      CRYPT_OID_INFO_OID_KEY,
 629                      rdn->rgRDNAttr[j].pszObjId,
 630                      CRYPT_RDN_ATTR_OID_GROUP_ID);
 631
 632                     if (oidInfo)
 633                         prefixW = oidInfo->pwszName;
 634                     else
 635                         prefixA = rdn->rgRDNAttr[j].pszObjId;
 636                 }
 637                 if (dwStrType & CERT_NAME_STR_CRLF_FLAG)
 638                 {
 639                     DWORD k;
 640
 641                     for (k = 0; k < indentLevel; k++)
 642                     {
 643                         if (psz)
 644                         {
 645                             chars = min(strlenW(indent), csz - ret - 1);
 646                             memcpy(psz + ret, indent, chars * sizeof(WCHAR));
 647                         }
 648                         else
 649                             chars = strlenW(indent);
 650                         ret += chars;
 651                     }
 652                 }
 653                 if (prefixW)
 654                 {
 655                     /* - 1 is needed to account for the NULL terminator. */
 656                     chars = CRYPT_AddPrefixW(prefixW,
 657                      psz ? psz + ret : NULL, psz ? csz - ret - 1 : 0);
 658                     ret += chars;
 659                 }
 660                 else if (prefixA)
 661                 {
 662                     /* - 1 is needed to account for the NULL terminator. */
 663                     chars = CRYPT_AddPrefixAToW(prefixA,
 664                      psz ? psz + ret : NULL, psz ? csz - ret - 1 : 0);
 665                     ret += chars;
 666                 }
 667                 chars = quote_rdn_value_to_str_w(
 668                  rdn->rgRDNAttr[j].dwValueType,
 669                  &rdn->rgRDNAttr[j].Value, psz ? psz + ret : NULL,
 670                  psz ? csz - ret : 0);
 671                 if (chars)
 672                     ret += chars - 1;
 673                 if (j < rdn->cRDNAttr - 1)
 674                 {
 675                     if (psz && ret < csz - rdnSepLen - 1)
 676                         memcpy(psz + ret, rdnSep, rdnSepLen * sizeof(WCHAR));
 677                     ret += rdnSepLen;
 678                 }
 679             }
 680             if (i < info->cRDN - 1)
 681             {
 682                 if (psz && ret < csz - sepLen - 1)
 683                     memcpy(psz + ret, sep, sepLen * sizeof(WCHAR));
 684                 ret += sepLen;
 685             }
 686             if(reverse) rdn--;
 687             else rdn++;
 688         }
 689         LocalFree(info);
 690     }
 691     if (psz && csz)
 692     {
 693         *(psz + ret) = '\0';
 694         ret++;
 695     }
 696     else
 697         ret++;
 698     return ret;
 699 }
 700
 701 DWORD WINAPI CertNameToStrW(DWORD dwCertEncodingType, PCERT_NAME_BLOB pName,
 702  DWORD dwStrType, LPWSTR psz, DWORD csz)
 703 {
 704     BOOL ret;
 705
 706     TRACE("(%d, %p, %08x, %p, %d)\n", dwCertEncodingType, pName, dwStrType,
 707      psz, csz);
 708
 709     ret = cert_name_to_str_with_indent(dwCertEncodingType, 0, pName, dwStrType,
 710      psz, csz);
 711     TRACE("Returning %s\n", debugstr_w(psz));
 712     return ret;
 713 }
 714
 715 BOOL WINAPI CertStrToNameA(DWORD dwCertEncodingType, LPCSTR pszX500,
 716  DWORD dwStrType, void *pvReserved, BYTE *pbEncoded, DWORD *pcbEncoded,
 717  LPCSTR *ppszError)
 718 {
 719     BOOL ret;
 720     int len;
 721
 722     TRACE("(%08x, %s, %08x, %p, %p, %p, %p)\n", dwCertEncodingType,
 723      debugstr_a(pszX500), dwStrType, pvReserved, pbEncoded, pcbEncoded,
 724      ppszError);
 725
 726     len = MultiByteToWideChar(CP_ACP, 0, pszX500, -1, NULL, 0);
 727     if (len)
 728     {
 729         LPWSTR x500, errorStr;
 730
 731         if ((x500 = CryptMemAlloc(len * sizeof(WCHAR))))
 732         {
 733             MultiByteToWideChar(CP_ACP, 0, pszX500, -1, x500, len);
 734             ret = CertStrToNameW(dwCertEncodingType, x500, dwStrType,
 735              pvReserved, pbEncoded, pcbEncoded,
 736              ppszError ? (LPCWSTR *)&errorStr : NULL);
 737             if (ppszError)
 738             {
 739                 if (!ret)
 740                 {
 741                     LONG i;
 742
 743                     *ppszError = pszX500;
 744                     for (i = 0; i < errorStr - x500; i++)
 745                         *ppszError = CharNextA(*ppszError);
 746                 }
 747                 else
 748                     *ppszError = NULL;
 749             }
 750             CryptMemFree(x500);
 751         }
 752         else
 753         {
 754             SetLastError(ERROR_OUTOFMEMORY);
 755             ret = FALSE;
 756         }
 757     }
 758     else
 759     {
 760         SetLastError(CRYPT_E_INVALID_X500_STRING);
 761         if (ppszError)
 762             *ppszError = pszX500;
 763         ret = FALSE;
 764     }
 765     return ret;
 766 }
 767
 768 struct KeynameKeeper
 769 {
 770     WCHAR  buf[10]; /* big enough for L"GivenName" */
 771     LPWSTR keyName; /* usually = buf, but may be allocated */
 772     DWORD  keyLen;
 773 };
 774
 775 static void CRYPT_InitializeKeynameKeeper(struct KeynameKeeper *keeper)
 776 {
 777     keeper->keyName = keeper->buf;
 778     keeper->keyLen = sizeof(keeper->buf) / sizeof(keeper->buf[0]);
 779 }
 780
 781 static void CRYPT_FreeKeynameKeeper(struct KeynameKeeper *keeper)
 782 {
 783     if (keeper->keyName != keeper->buf)
 784         CryptMemFree(keeper->keyName);
 785 }
 786
 787 struct X500TokenW
 788 {
 789     LPCWSTR start;
 790     LPCWSTR end;
 791 };
 792
 793 static void CRYPT_KeynameKeeperFromTokenW(struct KeynameKeeper *keeper,
 794  const struct X500TokenW *key)
 795 {
 796     DWORD len = key->end - key->start;
 797
 798     if (len > keeper->keyLen)
 799     {
 800         if (keeper->keyName == keeper->buf)
 801             keeper->keyName = CryptMemAlloc(len * sizeof(WCHAR));
 802         else
 803             keeper->keyName = CryptMemRealloc(keeper->keyName,
 804              len * sizeof(WCHAR));
 805         keeper->keyLen = len;
 806     }
 807     memcpy(keeper->keyName, key->start, (key->end - key->start) *
 808      sizeof(WCHAR));
 809     keeper->keyName[len] = '\0';
 810     TRACE("Keyname is %s\n", debugstr_w(keeper->keyName));
 811 }
 812
 813 static BOOL CRYPT_GetNextKeyW(LPCWSTR str, struct X500TokenW *token,
 814  LPCWSTR *ppszError)
 815 {
 816     BOOL ret = TRUE;
 817
 818     while (*str && isspaceW(*str))
 819         str++;
 820     if (*str)
 821     {
 822         token->start = str;
 823         while (*str && *str != '=' && !isspaceW(*str))
 824             str++;
 825         if (*str && (*str == '=' || isspaceW(*str)))
 826             token->end = str;
 827         else
 828         {
 829             TRACE("missing equals char at %s\n", debugstr_w(token->start));
 830             if (ppszError)
 831                 *ppszError = token->start;
 832             SetLastError(CRYPT_E_INVALID_X500_STRING);
 833             ret = FALSE;
 834         }
 835     }
 836     else
 837         token->start = NULL;
 838     return ret;
 839 }
 840
 841 /* Assumes separators are characters in the 0-255 range */
 842 static BOOL CRYPT_GetNextValueW(LPCWSTR str, DWORD dwFlags, LPCWSTR separators,
 843  struct X500TokenW *token, LPCWSTR *ppszError)
 844 {
 845     BOOL ret = TRUE;
 846
 847     TRACE("(%s, %s, %p, %p)\n", debugstr_w(str), debugstr_w(separators), token,
 848      ppszError);
 849
 850     while (*str && isspaceW(*str))
 851         str++;
 852     if (*str)
 853     {
 854         token->start = str;
 855         if (!(dwFlags & CERT_NAME_STR_NO_QUOTING_FLAG) && *str == '"')
 856         {
 857             token->end = NULL;
 858             str++;
 859             while (!token->end && ret)
 860             {
 861                 while (*str && *str != '"')
 862                     str++;
 863                 if (*str == '"')
 864                 {
 865                     if (*(str + 1) != '"')
 866                         token->end = str + 1;
 867                     else
 868                         str += 2;
 869                 }
 870                 else
 871                 {
 872                     TRACE("unterminated quote at %s\n", debugstr_w(str));
 873                     if (ppszError)
 874                         *ppszError = str;
 875                     SetLastError(CRYPT_E_INVALID_X500_STRING);
 876                     ret = FALSE;
 877                 }
 878             }
 879         }
 880         else
 881         {
 882             WCHAR map[256] = { 0 };
 883
 884             while (*separators)
 885                 map[*separators++] = 1;
 886             while (*str && (*str >= 0xff || !map[*str]))
 887                 str++;
 888             token->end = str;
 889         }
 890     }
 891     else
 892     {
 893         TRACE("missing value at %s\n", debugstr_w(str));
 894         if (ppszError)
 895             *ppszError = str;
 896         SetLastError(CRYPT_E_INVALID_X500_STRING);
 897         ret = FALSE;
 898     }
 899     return ret;
 900 }
 901
 902 /* Encodes the string represented by value as the string type type into the
 903  * CERT_NAME_BLOB output.  If there is an error and ppszError is not NULL,
 904  * *ppszError is set to the first failing character.  If there is no error,
 905  * output's pbData must be freed with LocalFree.
 906  */
 907 static BOOL CRYPT_EncodeValueWithType(DWORD dwCertEncodingType,
 908  const struct X500TokenW *value, PCERT_NAME_BLOB output, DWORD type,
 909  LPCWSTR *ppszError)
 910 {
 911     CERT_NAME_VALUE nameValue = { type, { 0, NULL } };
 912     BOOL ret = TRUE;
 913
 914     if (value->end > value->start)
 915     {
 916         LONG i;
 917         LPWSTR ptr;
 918
 919         nameValue.Value.pbData = CryptMemAlloc((value->end - value->start + 1) *
 920          sizeof(WCHAR));
 921         if (!nameValue.Value.pbData)
 922         {
 923             SetLastError(ERROR_OUTOFMEMORY);
 924             return FALSE;
 925         }
 926         ptr = (LPWSTR)nameValue.Value.pbData;
 927         for (i = 0; i < value->end - value->start; i++)
 928         {
 929             *ptr++ = value->start[i];
 930             if (value->start[i] == '"')
 931                 i++;
 932         }
 933         /* The string is NULL terminated because of a quirk in encoding
 934          * unicode names values:  if the length is given as 0, the value is
 935          * assumed to be a NULL-terminated string.
 936          */
 937         *ptr = 0;
 938         nameValue.Value.cbData = (LPBYTE)ptr - nameValue.Value.pbData;
 939     }
 940     ret = CryptEncodeObjectEx(dwCertEncodingType, X509_UNICODE_NAME_VALUE,
 941      &nameValue, CRYPT_ENCODE_ALLOC_FLAG, NULL, &output->pbData,
 942      &output->cbData);
 943     if (!ret && ppszError)
 944     {
 945         if (type == CERT_RDN_NUMERIC_STRING &&
 946          GetLastError() == CRYPT_E_INVALID_NUMERIC_STRING)
 947             *ppszError = value->start + output->cbData;
 948         else if (type == CERT_RDN_PRINTABLE_STRING &&
 949          GetLastError() == CRYPT_E_INVALID_PRINTABLE_STRING)
 950             *ppszError = value->start + output->cbData;
 951         else if (type == CERT_RDN_IA5_STRING &&
 952          GetLastError() == CRYPT_E_INVALID_IA5_STRING)
 953             *ppszError = value->start + output->cbData;
 954     }
 955     CryptMemFree(nameValue.Value.pbData);
 956     return ret;
 957 }
 958
 959 static BOOL CRYPT_EncodeValue(DWORD dwCertEncodingType,
 960  const struct X500TokenW *value, PCERT_NAME_BLOB output, const DWORD *types,
 961  LPCWSTR *ppszError)
 962 {
 963     DWORD i;
 964     BOOL ret;
 965
 966     ret = FALSE;
 967     for (i = 0; !ret && types[i]; i++)
 968         ret = CRYPT_EncodeValueWithType(dwCertEncodingType, value, output,
 969          types[i], ppszError);
 970     return ret;
 971 }
 972
 973 static BOOL CRYPT_ValueToRDN(DWORD dwCertEncodingType, PCERT_NAME_INFO info,
 974  PCCRYPT_OID_INFO keyOID, struct X500TokenW *value, DWORD dwStrType, LPCWSTR *ppszError)
 975 {
 976     BOOL ret = FALSE;
 977
 978     TRACE("OID %s, value %s\n", debugstr_a(keyOID->pszOID),
 979      debugstr_wn(value->start, value->end - value->start));
 980
 981     if (!info->rgRDN)
 982         info->rgRDN = CryptMemAlloc(sizeof(CERT_RDN));
 983     else
 984         info->rgRDN = CryptMemRealloc(info->rgRDN,
 985          (info->cRDN + 1) * sizeof(CERT_RDN));
 986     if (info->rgRDN)
 987     {
 988         /* FIXME: support multiple RDN attrs */
 989         info->rgRDN[info->cRDN].rgRDNAttr =
 990          CryptMemAlloc(sizeof(CERT_RDN_ATTR));
 991         if (info->rgRDN[info->cRDN].rgRDNAttr)
 992         {
 993             static const DWORD defaultTypes[] = { CERT_RDN_PRINTABLE_STRING,
 994              CERT_RDN_BMP_STRING, 0 };
 995             const DWORD *types;
 996
 997             info->rgRDN[info->cRDN].cRDNAttr = 1;
 998             info->rgRDN[info->cRDN].rgRDNAttr[0].pszObjId =
 999              (LPSTR)keyOID->pszOID;
1000             info->rgRDN[info->cRDN].rgRDNAttr[0].dwValueType =
1001              CERT_RDN_ENCODED_BLOB;
1002             if (keyOID->ExtraInfo.cbData)
1003                 types = (const DWORD *)keyOID->ExtraInfo.pbData;
1004             else
1005                 types = defaultTypes;
1006
1007             /* Remove surrounding quotes */
1008             if (value->start[0] == '"' && !(dwStrType & CERT_NAME_STR_NO_QUOTING_FLAG))
1009             {
1010                 value->start++;
1011                 value->end--;
1012             }
1013             ret = CRYPT_EncodeValue(dwCertEncodingType, value,
1014              &info->rgRDN[info->cRDN].rgRDNAttr[0].Value, types, ppszError);
1015         }
1016         else
1017             SetLastError(ERROR_OUTOFMEMORY);
1018         info->cRDN++;
1019     }
1020     else
1021         SetLastError(ERROR_OUTOFMEMORY);
1022     return ret;
1023 }
1024
1025 BOOL WINAPI CertStrToNameW(DWORD dwCertEncodingType, LPCWSTR pszX500,
1026  DWORD dwStrType, void *pvReserved, BYTE *pbEncoded, DWORD *pcbEncoded,
1027  LPCWSTR *ppszError)
1028 {
1029     CERT_NAME_INFO info = { 0, NULL };
1030     LPCWSTR str;
1031     struct KeynameKeeper keeper;
1032     DWORD i;
1033     BOOL ret = TRUE;
1034
1035     TRACE("(%08x, %s, %08x, %p, %p, %p, %p)\n", dwCertEncodingType,
1036      debugstr_w(pszX500), dwStrType, pvReserved, pbEncoded, pcbEncoded,
1037      ppszError);
1038
1039     CRYPT_InitializeKeynameKeeper(&keeper);
1040     str = pszX500;
1041     while (str && *str && ret)
1042     {
1043         struct X500TokenW token;
1044
1045         ret = CRYPT_GetNextKeyW(str, &token, ppszError);
1046         if (ret && token.start)
1047         {
1048             PCCRYPT_OID_INFO keyOID;
1049
1050             CRYPT_KeynameKeeperFromTokenW(&keeper, &token);
1051             keyOID = CryptFindOIDInfo(CRYPT_OID_INFO_NAME_KEY, keeper.keyName,
1052              CRYPT_RDN_ATTR_OID_GROUP_ID);
1053             if (!keyOID)
1054             {
1055                 if (ppszError)
1056                     *ppszError = token.start;
1057                 SetLastError(CRYPT_E_INVALID_X500_STRING);
1058                 ret = FALSE;
1059             }
1060             else
1061             {
1062                 str = token.end;
1063                 while (isspace(*str))
1064                     str++;
1065                 if (*str != '=')
1066                 {
1067                     if (ppszError)
1068                         *ppszError = str;
1069                     SetLastError(CRYPT_E_INVALID_X500_STRING);
1070                     ret = FALSE;
1071                 }
1072                 else
1073                 {
1074                     static const WCHAR commaSep[] = { ',',0 };
1075                     static const WCHAR semiSep[] = { ';',0 };
1076                     static const WCHAR crlfSep[] = { '\r','\n',0 };
1077                     static const WCHAR allSepsWithoutPlus[] = { ',',';','\r','\n',0 };
1078                     static const WCHAR allSeps[] = { '+',',',';','\r','\n',0 };
1079                     LPCWSTR sep;
1080
1081                     str++;
1082                     if (dwStrType & CERT_NAME_STR_COMMA_FLAG)
1083                         sep = commaSep;
1084                     else if (dwStrType & CERT_NAME_STR_SEMICOLON_FLAG)
1085                         sep = semiSep;
1086                     else if (dwStrType & CERT_NAME_STR_CRLF_FLAG)
1087                         sep = crlfSep;
1088                     else if (dwStrType & CERT_NAME_STR_NO_PLUS_FLAG)
1089                         sep = allSepsWithoutPlus;
1090                     else
1091                         sep = allSeps;
1092                     ret = CRYPT_GetNextValueW(str, dwStrType, sep, &token,
1093                      ppszError);
1094                     if (ret)
1095                     {
1096                         str = token.end;
1097                         ret = CRYPT_ValueToRDN(dwCertEncodingType, &info,
1098                          keyOID, &token, dwStrType, ppszError);
1099                     }
1100                 }
1101             }
1102         }
1103     }
1104     CRYPT_FreeKeynameKeeper(&keeper);
1105     if (ret)
1106     {
1107         if (ppszError)
1108             *ppszError = NULL;
1109         ret = CryptEncodeObjectEx(dwCertEncodingType, X509_NAME, &info,
1110          0, NULL, pbEncoded, pcbEncoded);
1111     }
1112     for (i = 0; i < info.cRDN; i++)
1113     {
1114         DWORD j;
1115
1116         for (j = 0; j < info.rgRDN[i].cRDNAttr; j++)
1117             LocalFree(info.rgRDN[i].rgRDNAttr[j].Value.pbData);
1118         CryptMemFree(info.rgRDN[i].rgRDNAttr);
1119     }
1120     CryptMemFree(info.rgRDN);
1121     return ret;
1122 }
1123
1124 DWORD WINAPI CertGetNameStringA(PCCERT_CONTEXT pCertContext, DWORD dwType,
1125  DWORD dwFlags, void *pvTypePara, LPSTR pszNameString, DWORD cchNameString)
1126 {
1127     DWORD ret;
1128
1129     TRACE("(%p, %d, %08x, %p, %p, %d)\n", pCertContext, dwType, dwFlags,
1130      pvTypePara, pszNameString, cchNameString);
1131
1132     if (pszNameString)
1133     {
1134         LPWSTR wideName;
1135         DWORD nameLen;
1136
1137         nameLen = CertGetNameStringW(pCertContext, dwType, dwFlags, pvTypePara,
1138          NULL, 0);
1139         wideName = CryptMemAlloc(nameLen * sizeof(WCHAR));
1140         if (wideName)
1141         {
1142             CertGetNameStringW(pCertContext, dwType, dwFlags, pvTypePara,
1143              wideName, nameLen);
1144             nameLen = WideCharToMultiByte(CP_ACP, 0, wideName, nameLen,
1145              pszNameString, cchNameString, NULL, NULL);
1146             if (nameLen <= cchNameString)
1147                 ret = nameLen;
1148             else
1149             {
1150                 pszNameString[cchNameString - 1] = '\0';
1151                 ret = cchNameString;
1152             }
1153             CryptMemFree(wideName);
1154         }
1155         else
1156         {
1157             *pszNameString = '\0';
1158             ret = 1;
1159         }
1160     }
1161     else
1162         ret = CertGetNameStringW(pCertContext, dwType, dwFlags, pvTypePara,
1163          NULL, 0);
1164     return ret;
1165 }
1166
1167 /* Searches cert's extensions for the alternate name extension with OID
1168  * altNameOID, and if found, searches it for the alternate name type entryType.
1169  * If found, returns a pointer to the entry, otherwise returns NULL.
1170  * Regardless of whether an entry of the desired type is found, if the
1171  * alternate name extension is present, sets *info to the decoded alternate
1172  * name extension, which you must free using LocalFree.
1173  * The return value is a pointer within *info, so don't free *info before
1174  * you're done with the return value.
1175  */
1176 static PCERT_ALT_NAME_ENTRY cert_find_alt_name_entry(PCCERT_CONTEXT cert,
1177  LPCSTR altNameOID, DWORD entryType, PCERT_ALT_NAME_INFO *info)
1178 {
1179     PCERT_ALT_NAME_ENTRY entry = NULL;
1180     PCERT_EXTENSION ext = CertFindExtension(altNameOID,
1181      cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
1182
1183     if (ext)
1184     {
1185         DWORD bytes = 0;
1186
1187         if (CryptDecodeObjectEx(cert->dwCertEncodingType, X509_ALTERNATE_NAME,
1188          ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
1189          info, &bytes))
1190         {
1191             DWORD i;
1192
1193             for (i = 0; !entry && i < (*info)->cAltEntry; i++)
1194                 if ((*info)->rgAltEntry[i].dwAltNameChoice == entryType)
1195                     entry = &(*info)->rgAltEntry[i];
1196         }
1197     }
1198     else
1199         *info = NULL;
1200     return entry;
1201 }
1202
1203 static DWORD cert_get_name_from_rdn_attr(DWORD encodingType,
1204  const CERT_NAME_BLOB *name, LPCSTR oid, LPWSTR pszNameString, DWORD cchNameString)
1205 {
1206     CERT_NAME_INFO *nameInfo;
1207     DWORD bytes = 0, ret = 0;
1208
1209     if (CryptDecodeObjectEx(encodingType, X509_NAME, name->pbData,
1210      name->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &nameInfo, &bytes))
1211     {
1212         PCERT_RDN_ATTR nameAttr;
1213
1214         if (!oid)
1215             oid = szOID_RSA_emailAddr;
1216         nameAttr = CertFindRDNAttr(oid, nameInfo);
1217         if (nameAttr)
1218             ret = CertRDNValueToStrW(nameAttr->dwValueType, &nameAttr->Value,
1219              pszNameString, cchNameString);
1220         LocalFree(nameInfo);
1221     }
1222     return ret;
1223 }
1224
1225 DWORD WINAPI CertGetNameStringW(PCCERT_CONTEXT pCertContext, DWORD dwType,
1226  DWORD dwFlags, void *pvTypePara, LPWSTR pszNameString, DWORD cchNameString)
1227 {
1228     DWORD ret = 0;
1229     PCERT_NAME_BLOB name;
1230     LPCSTR altNameOID;
1231
1232     TRACE("(%p, %d, %08x, %p, %p, %d)\n", pCertContext, dwType,
1233      dwFlags, pvTypePara, pszNameString, cchNameString);
1234
1235     if (!pCertContext)
1236         goto done;
1237
1238     if (dwFlags & CERT_NAME_ISSUER_FLAG)
1239     {
1240         name = &pCertContext->pCertInfo->Issuer;
1241         altNameOID = szOID_ISSUER_ALT_NAME;
1242     }
1243     else
1244     {
1245         name = &pCertContext->pCertInfo->Subject;
1246         altNameOID = szOID_SUBJECT_ALT_NAME;
1247     }
1248
1249     switch (dwType)
1250     {
1251     case CERT_NAME_EMAIL_TYPE:
1252     {
1253         CERT_ALT_NAME_INFO *info;
1254         PCERT_ALT_NAME_ENTRY entry = cert_find_alt_name_entry(pCertContext,
1255          altNameOID, CERT_ALT_NAME_RFC822_NAME, &info);
1256
1257         if (entry)
1258         {
1259             if (!pszNameString)
1260                 ret = strlenW(entry->u.pwszRfc822Name) + 1;
1261             else if (cchNameString)
1262             {
1263                 ret = min(strlenW(entry->u.pwszRfc822Name), cchNameString - 1);
1264                 memcpy(pszNameString, entry->u.pwszRfc822Name,
1265                  ret * sizeof(WCHAR));
1266                 pszNameString[ret++] = 0;
1267             }
1268         }
1269         if (info)
1270             LocalFree(info);
1271         if (!ret)
1272             ret = cert_get_name_from_rdn_attr(pCertContext->dwCertEncodingType,
1273              name, szOID_RSA_emailAddr, pszNameString, cchNameString);
1274         break;
1275     }
1276     case CERT_NAME_RDN_TYPE:
1277     {
1278         DWORD type = pvTypePara ? *(DWORD *)pvTypePara : 0;
1279
1280         if (name->cbData)
1281             ret = CertNameToStrW(pCertContext->dwCertEncodingType, name,
1282              type, pszNameString, cchNameString);
1283         else
1284         {
1285             CERT_ALT_NAME_INFO *info;
1286             PCERT_ALT_NAME_ENTRY entry = cert_find_alt_name_entry(pCertContext,
1287              altNameOID, CERT_ALT_NAME_DIRECTORY_NAME, &info);
1288
1289             if (entry)
1290                 ret = CertNameToStrW(pCertContext->dwCertEncodingType,
1291                  &entry->u.DirectoryName, type, pszNameString, cchNameString);
1292             if (info)
1293                 LocalFree(info);
1294         }
1295         break;
1296     }
1297     case CERT_NAME_ATTR_TYPE:
1298         ret = cert_get_name_from_rdn_attr(pCertContext->dwCertEncodingType,
1299          name, pvTypePara, pszNameString, cchNameString);
1300         if (!ret)
1301         {
1302             CERT_ALT_NAME_INFO *altInfo;
1303             PCERT_ALT_NAME_ENTRY entry = cert_find_alt_name_entry(pCertContext,
1304              altNameOID, CERT_ALT_NAME_DIRECTORY_NAME, &altInfo);
1305
1306             if (entry)
1307                 ret = cert_name_to_str_with_indent(X509_ASN_ENCODING, 0,
1308                  &entry->u.DirectoryName, 0, pszNameString, cchNameString);
1309             if (altInfo)
1310                 LocalFree(altInfo);
1311         }
1312         break;
1313     case CERT_NAME_SIMPLE_DISPLAY_TYPE:
1314     {
1315         static const LPCSTR simpleAttributeOIDs[] = { szOID_COMMON_NAME,
1316          szOID_ORGANIZATIONAL_UNIT_NAME, szOID_ORGANIZATION_NAME,
1317          szOID_RSA_emailAddr };
1318         CERT_NAME_INFO *nameInfo = NULL;
1319         DWORD bytes = 0, i;
1320
1321         if (CryptDecodeObjectEx(pCertContext->dwCertEncodingType, X509_NAME,
1322          name->pbData, name->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &nameInfo,
1323          &bytes))
1324         {
1325             PCERT_RDN_ATTR nameAttr = NULL;
1326
1327             for (i = 0; !nameAttr && i < sizeof(simpleAttributeOIDs) /
1328              sizeof(simpleAttributeOIDs[0]); i++)
1329                 nameAttr = CertFindRDNAttr(simpleAttributeOIDs[i], nameInfo);
1330             if (nameAttr)
1331                 ret = CertRDNValueToStrW(nameAttr->dwValueType,
1332                  &nameAttr->Value, pszNameString, cchNameString);
1333             LocalFree(nameInfo);
1334         }
1335         if (!ret)
1336         {
1337             CERT_ALT_NAME_INFO *altInfo;
1338             PCERT_ALT_NAME_ENTRY entry = cert_find_alt_name_entry(pCertContext,
1339              altNameOID, CERT_ALT_NAME_RFC822_NAME, &altInfo);
1340
1341             if (altInfo)
1342             {
1343                 if (!entry && altInfo->cAltEntry)
1344                     entry = &altInfo->rgAltEntry[0];
1345                 if (entry)
1346                 {
1347                     if (!pszNameString)
1348                         ret = strlenW(entry->u.pwszRfc822Name) + 1;
1349                     else if (cchNameString)
1350                     {
1351                         ret = min(strlenW(entry->u.pwszRfc822Name),
1352                          cchNameString - 1);
1353                         memcpy(pszNameString, entry->u.pwszRfc822Name,
1354                          ret * sizeof(WCHAR));
1355                         pszNameString[ret++] = 0;
1356                     }
1357                 }
1358                 LocalFree(altInfo);
1359             }
1360         }
1361         break;
1362     }
1363     case CERT_NAME_FRIENDLY_DISPLAY_TYPE:
1364     {
1365         DWORD cch = cchNameString;
1366
1367         if (CertGetCertificateContextProperty(pCertContext,
1368          CERT_FRIENDLY_NAME_PROP_ID, pszNameString, &cch))
1369             ret = cch;
1370         else
1371             ret = CertGetNameStringW(pCertContext,
1372              CERT_NAME_SIMPLE_DISPLAY_TYPE, dwFlags, pvTypePara, pszNameString,
1373              cchNameString);
1374         break;
1375     }
1376     case CERT_NAME_DNS_TYPE:
1377     {
1378         CERT_ALT_NAME_INFO *info;
1379         PCERT_ALT_NAME_ENTRY entry = cert_find_alt_name_entry(pCertContext,
1380          altNameOID, CERT_ALT_NAME_DNS_NAME, &info);
1381
1382         if (entry)
1383         {
1384             if (!pszNameString)
1385                 ret = strlenW(entry->u.pwszDNSName) + 1;
1386             else if (cchNameString)
1387             {
1388                 ret = min(strlenW(entry->u.pwszDNSName), cchNameString - 1);
1389                 memcpy(pszNameString, entry->u.pwszDNSName, ret * sizeof(WCHAR));
1390                 pszNameString[ret++] = 0;
1391             }
1392         }
1393         if (info)
1394             LocalFree(info);
1395         if (!ret)
1396             ret = cert_get_name_from_rdn_attr(pCertContext->dwCertEncodingType,
1397              name, szOID_COMMON_NAME, pszNameString, cchNameString);
1398         break;
1399     }
1400     case CERT_NAME_URL_TYPE:
1401     {
1402         CERT_ALT_NAME_INFO *info;
1403         PCERT_ALT_NAME_ENTRY entry = cert_find_alt_name_entry(pCertContext,
1404          altNameOID, CERT_ALT_NAME_URL, &info);
1405
1406         if (entry)
1407         {
1408             if (!pszNameString)
1409                 ret = strlenW(entry->u.pwszURL) + 1;
1410             else if (cchNameString)
1411             {
1412                 ret = min(strlenW(entry->u.pwszURL), cchNameString - 1);
1413                 memcpy(pszNameString, entry->u.pwszURL, ret * sizeof(WCHAR));
1414                 pszNameString[ret++] = 0;
1415             }
1416         }
1417         if (info)
1418             LocalFree(info);
1419         break;
1420     }
1421     default:
1422         FIXME("unimplemented for type %d\n", dwType);
1423         ret = 0;
1424     }
1425 done:
1426     if (!ret)
1427     {
1428         if (!pszNameString)
1429             ret = 1;
1430         else if (cchNameString)
1431         {
1432             pszNameString[0] = 0;
1433             ret = 1;
1434         }
1435     }
1436     return ret;
1437 }