setupapi: Implement SetupDiCreateDevRegKeyW.
[wine] / 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 #include "windef.h"
20 #include "winbase.h"
21 #include "winnls.h"
22 #include "winuser.h"
23 #include "wincrypt.h"
24 #include "wine/debug.h"
25 #include "wine/unicode.h"
26
27 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
28
29 DWORD WINAPI CertRDNValueToStrA(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue,
30  LPSTR psz, DWORD csz)
31 {
32     DWORD ret = 0;
33
34     TRACE("(%d, %p, %p, %d)\n", dwValueType, pValue, psz, csz);
35
36     switch (dwValueType)
37     {
38     case CERT_RDN_ANY_TYPE:
39         break;
40     case CERT_RDN_NUMERIC_STRING:
41     case CERT_RDN_PRINTABLE_STRING:
42     case CERT_RDN_TELETEX_STRING:
43     case CERT_RDN_VIDEOTEX_STRING:
44     case CERT_RDN_IA5_STRING:
45     case CERT_RDN_GRAPHIC_STRING:
46     case CERT_RDN_VISIBLE_STRING:
47     case CERT_RDN_GENERAL_STRING:
48         if (!psz || !csz)
49             ret = pValue->cbData;
50         else
51         {
52             DWORD chars = min(pValue->cbData, csz - 1);
53
54             if (chars)
55             {
56                 memcpy(psz, pValue->pbData, chars);
57                 ret += chars;
58                 csz -= chars;
59             }
60         }
61         break;
62     case CERT_RDN_UTF8_STRING:
63         if (!psz || !csz)
64             ret = WideCharToMultiByte(CP_UTF8, 0, (LPWSTR)pValue->pbData,
65              pValue->cbData / sizeof(WCHAR) + 1, NULL, 0, NULL, NULL);
66         else
67         {
68             ret = WideCharToMultiByte(CP_UTF8, 0, (LPWSTR)pValue->pbData,
69              pValue->cbData / sizeof(WCHAR) + 1, psz, csz - 1, NULL, NULL);
70             csz -= ret;
71         }
72         break;
73     default:
74         FIXME("string type %d unimplemented\n", dwValueType);
75     }
76     if (psz && csz)
77     {
78         *(psz + ret) = '\0';
79         csz--;
80         ret++;
81     }
82     else
83         ret++;
84     TRACE("returning %d (%s)\n", ret, debugstr_a(psz));
85     return ret;
86 }
87
88 DWORD WINAPI CertRDNValueToStrW(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue,
89  LPWSTR psz, DWORD csz)
90 {
91     DWORD ret = 0;
92
93     TRACE("(%d, %p, %p, %d)\n", dwValueType, pValue, psz, csz);
94
95     switch (dwValueType)
96     {
97     case CERT_RDN_ANY_TYPE:
98         break;
99     case CERT_RDN_NUMERIC_STRING:
100     case CERT_RDN_PRINTABLE_STRING:
101     case CERT_RDN_TELETEX_STRING:
102     case CERT_RDN_VIDEOTEX_STRING:
103     case CERT_RDN_IA5_STRING:
104     case CERT_RDN_GRAPHIC_STRING:
105     case CERT_RDN_VISIBLE_STRING:
106     case CERT_RDN_GENERAL_STRING:
107         if (!psz || !csz)
108             ret = pValue->cbData;
109         else
110         {
111             DWORD chars = min(pValue->cbData, csz - 1);
112
113             if (chars)
114             {
115                 DWORD i;
116
117                 for (i = 0; i < chars; i++)
118                     psz[i] = pValue->pbData[i];
119                 ret += chars;
120                 csz -= chars;
121             }
122         }
123         break;
124     case CERT_RDN_UTF8_STRING:
125         if (!psz || !csz)
126             ret = pValue->cbData / sizeof(WCHAR);
127         else
128         {
129             DWORD chars = min(pValue->cbData / sizeof(WCHAR), csz - 1);
130
131             if (chars)
132             {
133                 DWORD i;
134
135                 for (i = 0; i < chars; i++)
136                     psz[i] = *((LPWSTR)pValue->pbData + i);
137                 ret += chars;
138                 csz -= chars;
139             }
140         }
141         break;
142     default:
143         FIXME("string type %d unimplemented\n", dwValueType);
144     }
145     if (psz && csz)
146     {
147         *(psz + ret) = '\0';
148         csz--;
149         ret++;
150     }
151     else
152         ret++;
153     TRACE("returning %d (%s)\n", ret, debugstr_w(psz));
154     return ret;
155 }
156
157 /* Adds the prefix prefix to the string pointed to by psz, followed by the
158  * character '='.  Copies no more than csz characters.  Returns the number of
159  * characters copied.  If psz is NULL, returns the number of characters that
160  * would be copied.
161  */
162 static DWORD CRYPT_AddPrefixA(LPCSTR prefix, LPSTR psz, DWORD csz)
163 {
164     DWORD chars;
165
166     TRACE("(%s, %p, %d)\n", debugstr_a(prefix), psz, csz);
167
168     if (psz)
169     {
170         chars = min(lstrlenA(prefix), csz);
171         memcpy(psz, prefix, chars);
172         csz -= chars;
173         *(psz + chars) = '=';
174         chars++;
175         csz--;
176     }
177     else
178         chars = lstrlenA(prefix) + 1;
179     return chars;
180 }
181
182 DWORD WINAPI CertNameToStrA(DWORD dwCertEncodingType, PCERT_NAME_BLOB pName,
183  DWORD dwStrType, LPSTR psz, DWORD csz)
184 {
185     static const DWORD unsupportedFlags = CERT_NAME_STR_NO_QUOTING_FLAG |
186      CERT_NAME_STR_REVERSE_FLAG | CERT_NAME_STR_ENABLE_T61_UNICODE_FLAG;
187     static const char commaSep[] = ", ";
188     static const char semiSep[] = "; ";
189     static const char crlfSep[] = "\r\n";
190     static const char plusSep[] = " + ";
191     static const char spaceSep[] = " ";
192     DWORD ret = 0, bytes = 0;
193     BOOL bRet;
194     CERT_NAME_INFO *info;
195
196     TRACE("(%d, %p, %08x, %p, %d)\n", dwCertEncodingType, pName, dwStrType,
197      psz, csz);
198     if (dwStrType & unsupportedFlags)
199         FIXME("unsupported flags: %08x\n", dwStrType & unsupportedFlags);
200
201     bRet = CryptDecodeObjectEx(dwCertEncodingType, X509_NAME, pName->pbData,
202      pName->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &bytes);
203     if (bRet)
204     {
205         DWORD i, j, sepLen, rdnSepLen;
206         LPCSTR sep, rdnSep;
207
208         if (dwStrType & CERT_NAME_STR_SEMICOLON_FLAG)
209             sep = semiSep;
210         else if (dwStrType & CERT_NAME_STR_CRLF_FLAG)
211             sep = crlfSep;
212         else
213             sep = commaSep;
214         sepLen = strlen(sep);
215         if (dwStrType & CERT_NAME_STR_NO_PLUS_FLAG)
216             rdnSep = spaceSep;
217         else
218             rdnSep = plusSep;
219         rdnSepLen = strlen(rdnSep);
220         for (i = 0; (!psz || ret < csz) && i < info->cRDN; i++)
221         {
222             for (j = 0; (!psz || ret < csz) && j < info->rgRDN[i].cRDNAttr; j++)
223             {
224                 DWORD chars;
225                 char prefixBuf[10]; /* big enough for GivenName */
226                 LPCSTR prefix = NULL;
227
228                 if ((dwStrType & 0x000000ff) == CERT_OID_NAME_STR)
229                     prefix = info->rgRDN[i].rgRDNAttr[j].pszObjId;
230                 else if ((dwStrType & 0x000000ff) == CERT_X500_NAME_STR)
231                 {
232                     PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(
233                      CRYPT_OID_INFO_OID_KEY,
234                      info->rgRDN[i].rgRDNAttr[j].pszObjId,
235                      CRYPT_RDN_ATTR_OID_GROUP_ID);
236
237                     if (oidInfo)
238                     {
239                         WideCharToMultiByte(CP_ACP, 0, oidInfo->pwszName, -1,
240                          prefixBuf, sizeof(prefixBuf), NULL, NULL);
241                         prefix = prefixBuf;
242                     }
243                     else
244                         prefix = info->rgRDN[i].rgRDNAttr[j].pszObjId;
245                 }
246                 if (prefix)
247                 {
248                     /* - 1 is needed to account for the NULL terminator. */
249                     chars = CRYPT_AddPrefixA(prefix,
250                      psz ? psz + ret : NULL, psz ? csz - ret - 1 : 0);
251                     ret += chars;
252                     csz -= chars;
253                 }
254                 /* FIXME: handle quoting */
255                 chars = CertRDNValueToStrA(
256                  info->rgRDN[i].rgRDNAttr[j].dwValueType, 
257                  &info->rgRDN[i].rgRDNAttr[j].Value, psz ? psz + ret : NULL,
258                  psz ? csz - ret : 0);
259                 if (chars)
260                     ret += chars - 1;
261                 if (j < info->rgRDN[i].cRDNAttr - 1)
262                 {
263                     if (psz && ret < csz - rdnSepLen - 1)
264                         memcpy(psz + ret, rdnSep, rdnSepLen);
265                     ret += rdnSepLen;
266                 }
267             }
268             if (i < info->cRDN - 1)
269             {
270                 if (psz && ret < csz - sepLen - 1)
271                     memcpy(psz + ret, sep, sepLen);
272                 ret += sepLen;
273             }
274         }
275         LocalFree(info);
276     }
277     if (psz && csz)
278     {
279         *(psz + ret) = '\0';
280         csz--;
281         ret++;
282     }
283     else
284         ret++;
285     TRACE("Returning %s\n", debugstr_a(psz));
286     return ret;
287 }
288
289 /* Adds the prefix prefix to the wide-character string pointed to by psz,
290  * followed by the character '='.  Copies no more than csz characters.  Returns
291  * the number of characters copied.  If psz is NULL, returns the number of
292  * characters that would be copied.
293  * Assumes the characters in prefix are ASCII (not multibyte characters.)
294  */
295 static DWORD CRYPT_AddPrefixAToW(LPCSTR prefix, LPWSTR psz, DWORD csz)
296 {
297     DWORD chars;
298
299     TRACE("(%s, %p, %d)\n", debugstr_a(prefix), psz, csz);
300
301     if (psz)
302     {
303         DWORD i;
304
305         chars = min(lstrlenA(prefix), csz);
306         for (i = 0; i < chars; i++)
307             *(psz + i) = prefix[i];
308         csz -= chars;
309         *(psz + chars) = '=';
310         chars++;
311         csz--;
312     }
313     else
314         chars = lstrlenA(prefix) + 1;
315     return chars;
316 }
317
318 /* Adds the prefix prefix to the string pointed to by psz, followed by the
319  * character '='.  Copies no more than csz characters.  Returns the number of
320  * characters copied.  If psz is NULL, returns the number of characters that
321  * would be copied.
322  */
323 static DWORD CRYPT_AddPrefixW(LPCWSTR prefix, LPWSTR psz, DWORD csz)
324 {
325     DWORD chars;
326
327     TRACE("(%s, %p, %d)\n", debugstr_w(prefix), psz, csz);
328
329     if (psz)
330     {
331         chars = min(lstrlenW(prefix), csz);
332         memcpy(psz, prefix, chars * sizeof(WCHAR));
333         csz -= chars;
334         *(psz + chars) = '=';
335         chars++;
336         csz--;
337     }
338     else
339         chars = lstrlenW(prefix) + 1;
340     return chars;
341 }
342
343 DWORD WINAPI CertNameToStrW(DWORD dwCertEncodingType, PCERT_NAME_BLOB pName,
344  DWORD dwStrType, LPWSTR psz, DWORD csz)
345 {
346     static const DWORD unsupportedFlags = CERT_NAME_STR_NO_QUOTING_FLAG |
347      CERT_NAME_STR_REVERSE_FLAG | CERT_NAME_STR_ENABLE_T61_UNICODE_FLAG;
348     static const WCHAR commaSep[] = { ',',' ',0 };
349     static const WCHAR semiSep[] = { ';',' ',0 };
350     static const WCHAR crlfSep[] = { '\r','\n',0 };
351     static const WCHAR plusSep[] = { ' ','+',' ',0 };
352     static const WCHAR spaceSep[] = { ' ',0 };
353     DWORD ret = 0, bytes = 0;
354     BOOL bRet;
355     CERT_NAME_INFO *info;
356
357     TRACE("(%d, %p, %08x, %p, %d)\n", dwCertEncodingType, pName, dwStrType,
358      psz, csz);
359     if (dwStrType & unsupportedFlags)
360         FIXME("unsupported flags: %08x\n", dwStrType & unsupportedFlags);
361
362     bRet = CryptDecodeObjectEx(dwCertEncodingType, X509_NAME, pName->pbData,
363      pName->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &bytes);
364     if (bRet)
365     {
366         DWORD i, j, sepLen, rdnSepLen;
367         LPCWSTR sep, rdnSep;
368
369         if (dwStrType & CERT_NAME_STR_SEMICOLON_FLAG)
370             sep = semiSep;
371         else if (dwStrType & CERT_NAME_STR_CRLF_FLAG)
372             sep = crlfSep;
373         else
374             sep = commaSep;
375         sepLen = lstrlenW(sep);
376         if (dwStrType & CERT_NAME_STR_NO_PLUS_FLAG)
377             rdnSep = spaceSep;
378         else
379             rdnSep = plusSep;
380         rdnSepLen = lstrlenW(rdnSep);
381         for (i = 0; (!psz || ret < csz) && i < info->cRDN; i++)
382         {
383             for (j = 0; (!psz || ret < csz) && j < info->rgRDN[i].cRDNAttr; j++)
384             {
385                 DWORD chars;
386                 LPCSTR prefixA = NULL;
387                 LPCWSTR prefixW = NULL;
388
389                 if ((dwStrType & 0x000000ff) == CERT_OID_NAME_STR)
390                     prefixA = info->rgRDN[i].rgRDNAttr[j].pszObjId;
391                 else if ((dwStrType & 0x000000ff) == CERT_X500_NAME_STR)
392                 {
393                     PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(
394                      CRYPT_OID_INFO_OID_KEY,
395                      info->rgRDN[i].rgRDNAttr[j].pszObjId,
396                      CRYPT_RDN_ATTR_OID_GROUP_ID);
397
398                     if (oidInfo)
399                         prefixW = oidInfo->pwszName;
400                     else
401                         prefixA = info->rgRDN[i].rgRDNAttr[j].pszObjId;
402                 }
403                 if (prefixW)
404                 {
405                     /* - 1 is needed to account for the NULL terminator. */
406                     chars = CRYPT_AddPrefixW(prefixW,
407                      psz ? psz + ret : NULL, psz ? csz - ret - 1 : 0);
408                     ret += chars;
409                     csz -= chars;
410                 }
411                 else if (prefixA)
412                 {
413                     /* - 1 is needed to account for the NULL terminator. */
414                     chars = CRYPT_AddPrefixAToW(prefixA,
415                      psz ? psz + ret : NULL, psz ? csz - ret - 1 : 0);
416                     ret += chars;
417                     csz -= chars;
418                 }
419                 /* FIXME: handle quoting */
420                 chars = CertRDNValueToStrW(
421                  info->rgRDN[i].rgRDNAttr[j].dwValueType, 
422                  &info->rgRDN[i].rgRDNAttr[j].Value, psz ? psz + ret : NULL,
423                  psz ? csz - ret : 0);
424                 if (chars)
425                     ret += chars - 1;
426                 if (j < info->rgRDN[i].cRDNAttr - 1)
427                 {
428                     if (psz && ret < csz - rdnSepLen - 1)
429                         memcpy(psz + ret, rdnSep, rdnSepLen * sizeof(WCHAR));
430                     ret += rdnSepLen;
431                 }
432             }
433             if (i < info->cRDN - 1)
434             {
435                 if (psz && ret < csz - sepLen - 1)
436                     memcpy(psz + ret, sep, sepLen * sizeof(WCHAR));
437                 ret += sepLen;
438             }
439         }
440         LocalFree(info);
441     }
442     if (psz && csz)
443     {
444         *(psz + ret) = '\0';
445         csz--;
446         ret++;
447     }
448     else
449         ret++;
450     TRACE("Returning %s\n", debugstr_w(psz));
451     return ret;
452 }
453
454 BOOL WINAPI CertStrToNameA(DWORD dwCertEncodingType, LPCSTR pszX500,
455  DWORD dwStrType, void *pvReserved, BYTE *pbEncoded, DWORD *pcbEncoded,
456  LPCSTR *ppszError)
457 {
458     LPWSTR x500, errorStr;
459     BOOL ret;
460     int len;
461
462     TRACE("(%08x, %s, %08x, %p, %p, %p, %p)\n", dwCertEncodingType,
463      debugstr_a(pszX500), dwStrType, pvReserved, pbEncoded, pcbEncoded,
464      ppszError);
465
466     len = MultiByteToWideChar(CP_ACP, 0, pszX500, -1, NULL, 0);
467     x500 = CryptMemAlloc(len * sizeof(WCHAR));
468     if (x500)
469     {
470         MultiByteToWideChar(CP_ACP, 0, pszX500, -1, x500, len);
471         ret = CertStrToNameW(dwCertEncodingType, x500, dwStrType, pvReserved,
472          pbEncoded, pcbEncoded, ppszError ? (LPCWSTR *)&errorStr : NULL);
473         if (ppszError)
474         {
475             DWORD i;
476
477             *ppszError = pszX500;
478             for (i = 0; i < errorStr - x500; i++)
479                 *ppszError = CharNextA(*ppszError);
480         }
481         CryptMemFree(x500);
482     }
483     else
484         ret = FALSE;
485     return ret;
486 }
487
488 struct KeynameKeeper
489 {
490     WCHAR  buf[10]; /* big enough for L"GivenName" */
491     LPWSTR keyName; /* usually = buf, but may be allocated */
492     DWORD  keyLen;
493 };
494
495 static void CRYPT_InitializeKeynameKeeper(struct KeynameKeeper *keeper)
496 {
497     keeper->keyName = keeper->buf;
498     keeper->keyLen = sizeof(keeper->buf) / sizeof(keeper->buf[0]);
499 }
500
501 static void CRYPT_FreeKeynameKeeper(struct KeynameKeeper *keeper)
502 {
503     if (keeper->keyName != keeper->buf)
504         CryptMemFree(keeper->keyName);
505 }
506
507 struct X500TokenW
508 {
509     LPCWSTR start;
510     LPCWSTR end;
511 };
512
513 static void CRYPT_KeynameKeeperFromTokenW(struct KeynameKeeper *keeper,
514  const struct X500TokenW *key)
515 {
516     DWORD len = key->end - key->start;
517
518     if (len > keeper->keyLen)
519     {
520         if (keeper->keyName == keeper->buf)
521             keeper->keyName = CryptMemAlloc(len * sizeof(WCHAR));
522         else
523             keeper->keyName = CryptMemRealloc(keeper->keyName,
524              len * sizeof(WCHAR));
525         keeper->keyLen = len;
526     }
527     memcpy(keeper->keyName, key->start, (key->end - key->start) *
528      sizeof(WCHAR));
529     keeper->keyName[len] = '\0';
530     TRACE("Keyname is %s\n", debugstr_w(keeper->keyName));
531 }
532
533 static DWORD CRYPT_GetNextKeyW(LPCWSTR str, struct X500TokenW *token,
534  LPCWSTR *ppszError)
535 {
536     DWORD ret = ERROR_SUCCESS;
537
538     while (*str && isspaceW(*str))
539         str++;
540     if (*str)
541     {
542         token->start = str;
543         while (*str && *str != '=' && !isspaceW(*str))
544             str++;
545         if (*str && (*str == '=' || isspaceW(*str)))
546             token->end = str;
547         else
548         {
549             TRACE("missing equals char at %s\n", debugstr_w(token->start));
550             if (ppszError)
551                 *ppszError = token->start;
552             ret = CRYPT_E_INVALID_X500_STRING;
553         }
554     }
555     else
556         token->start = NULL;
557     return ret;
558 }
559
560 /* Assumes separators are characters in the 0-255 range */
561 static DWORD CRYPT_GetNextValueW(LPCWSTR str, DWORD dwFlags, LPCWSTR separators,
562  struct X500TokenW *token, LPCWSTR *ppszError)
563 {
564     DWORD ret = ERROR_SUCCESS;
565
566     TRACE("(%s, %s, %p, %p)\n", debugstr_w(str), debugstr_w(separators), token,
567      ppszError);
568
569     while (*str && isspaceW(*str))
570         str++;
571     if (*str)
572     {
573         token->start = str;
574         if (!(dwFlags & CERT_NAME_STR_NO_QUOTING_FLAG) && *str == '"')
575         {
576             token->end = NULL;
577             str++;
578             while (!token->end && !ret)
579             {
580                 while (*str && *str != '"')
581                     str++;
582                 if (*str == '"')
583                 {
584                     if (*(str + 1) != '"')
585                         token->end = str + 1;
586                     else
587                         str += 2;
588                 }
589                 else
590                 {
591                     TRACE("unterminated quote at %s\n", debugstr_w(str));
592                     if (ppszError)
593                         *ppszError = str;
594                     ret = CRYPT_E_INVALID_X500_STRING;
595                 }
596             }
597         }
598         else
599         {
600             WCHAR map[256] = { 0 };
601
602             while (*separators)
603                 map[*separators++] = 1;
604             while (*str && (*str >= 0xff || !map[*(const unsigned short *)str]))
605                 str++;
606             token->end = str;
607         }
608     }
609     else
610     {
611         TRACE("missing value at %s\n", debugstr_w(str));
612         if (ppszError)
613             *ppszError = str;
614         ret = CRYPT_E_INVALID_X500_STRING;
615     }
616     return ret;
617 }
618
619 /* Encodes the string represented by value as the string type type into the
620  * CERT_NAME_BLOB output.  If there is an error and ppszError is not NULL,
621  * *ppszError is set to the first failing character.  If there is no error,
622  * output's pbData must be freed with LocalFree.
623  */
624 static BOOL CRYPT_EncodeValueWithType(DWORD dwCertEncodingType,
625  const struct X500TokenW *value, PCERT_NAME_BLOB output, DWORD type,
626  LPCWSTR *ppszError)
627 {
628     CERT_NAME_VALUE nameValue = { type, { 0, NULL } };
629     BOOL ret = FALSE;
630
631     nameValue.Value.pbData = CryptMemAlloc((value->end - value->start) *
632      sizeof(WCHAR));
633     if (nameValue.Value.pbData)
634     {
635         DWORD i;
636         LPWSTR ptr = (LPWSTR)nameValue.Value.pbData;
637
638         for (i = 0; i < value->end - value->start; i++)
639         {
640             *ptr++ = value->start[i];
641             if (value->start[i] == '"')
642                 i++;
643         }
644         nameValue.Value.cbData = (LPBYTE)ptr - nameValue.Value.pbData;
645         ret = CryptEncodeObjectEx(dwCertEncodingType, X509_UNICODE_NAME_VALUE,
646          &nameValue, CRYPT_ENCODE_ALLOC_FLAG, NULL, &output->pbData,
647          &output->cbData);
648         if (!ret && ppszError)
649         {
650             if (type == CERT_RDN_NUMERIC_STRING &&
651              GetLastError() == CRYPT_E_INVALID_NUMERIC_STRING)
652                 *ppszError = value->start + output->cbData;
653             else if (type == CERT_RDN_PRINTABLE_STRING &&
654              GetLastError() == CRYPT_E_INVALID_PRINTABLE_STRING)
655                 *ppszError = value->start + output->cbData;
656             else if (type == CERT_RDN_IA5_STRING &&
657              GetLastError() == CRYPT_E_INVALID_IA5_STRING)
658                 *ppszError = value->start + output->cbData;
659         }
660         CryptMemFree(nameValue.Value.pbData);
661     }
662     return ret;
663 }
664
665 static BOOL CRYPT_EncodeValue(DWORD dwCertEncodingType,
666  const struct X500TokenW *value, PCERT_NAME_BLOB output, const DWORD *types,
667  LPCWSTR *ppszError)
668 {
669     DWORD i;
670     BOOL ret;
671
672     ret = FALSE;
673     for (i = 0; !ret && types[i]; i++)
674         ret = CRYPT_EncodeValueWithType(dwCertEncodingType, value, output,
675          types[i], ppszError);
676     return ret;
677 }
678
679 static BOOL CRYPT_ValueToRDN(DWORD dwCertEncodingType, PCERT_NAME_INFO info,
680  PCCRYPT_OID_INFO keyOID, struct X500TokenW *value, LPCWSTR *ppszError)
681 {
682     BOOL ret = FALSE;
683
684     TRACE("OID %s, value %s\n", debugstr_a(keyOID->pszOID),
685      debugstr_wn(value->start, value->end - value->start));
686
687     if (!info->rgRDN)
688         info->rgRDN = CryptMemAlloc(sizeof(CERT_RDN));
689     else
690         info->rgRDN = CryptMemRealloc(info->rgRDN,
691          (info->cRDN + 1) * sizeof(CERT_RDN));
692     if (info->rgRDN)
693     {
694         /* FIXME: support multiple RDN attrs */
695         info->rgRDN[info->cRDN].rgRDNAttr =
696          CryptMemAlloc(sizeof(CERT_RDN_ATTR));
697         if (info->rgRDN[info->cRDN].rgRDNAttr)
698         {
699             static const DWORD defaultTypes[] = { CERT_RDN_PRINTABLE_STRING,
700              CERT_RDN_BMP_STRING, 0 };
701             const DWORD *types;
702
703             info->rgRDN[info->cRDN].cRDNAttr = 1;
704             info->rgRDN[info->cRDN].rgRDNAttr[0].pszObjId =
705              (LPSTR)keyOID->pszOID;
706             info->rgRDN[info->cRDN].rgRDNAttr[0].dwValueType =
707              CERT_RDN_ENCODED_BLOB;
708             if (keyOID->ExtraInfo.cbData)
709                 types = (const DWORD *)keyOID->ExtraInfo.pbData;
710             else
711                 types = defaultTypes;
712
713             /* Remove surrounding quotes */
714             if (value->start[0] == '"')
715             {
716                 value->start++;
717                 value->end--;
718             }
719             ret = CRYPT_EncodeValue(dwCertEncodingType, value,
720              &info->rgRDN[info->cRDN].rgRDNAttr[0].Value, types, ppszError);
721         }
722     }
723     if (ret)
724         info->cRDN++;
725     return ret;
726 }
727
728 BOOL WINAPI CertStrToNameW(DWORD dwCertEncodingType, LPCWSTR pszX500,
729  DWORD dwStrType, void *pvReserved, BYTE *pbEncoded, DWORD *pcbEncoded,
730  LPCWSTR *ppszError)
731 {
732     CERT_NAME_INFO info = { 0, NULL };
733     LPCWSTR str;
734     struct KeynameKeeper keeper;
735     DWORD i, error = ERROR_SUCCESS;
736     BOOL ret = TRUE;
737
738     TRACE("(%08x, %s, %08x, %p, %p, %p, %p)\n", dwCertEncodingType,
739      debugstr_w(pszX500), dwStrType, pvReserved, pbEncoded, pcbEncoded,
740      ppszError);
741
742     CRYPT_InitializeKeynameKeeper(&keeper);
743     str = pszX500;
744     while (str && *str && !error && ret)
745     {
746         struct X500TokenW token;
747
748         error = CRYPT_GetNextKeyW(str, &token, ppszError);
749         if (!error && token.start)
750         {
751             PCCRYPT_OID_INFO keyOID;
752
753             CRYPT_KeynameKeeperFromTokenW(&keeper, &token);
754             keyOID = CryptFindOIDInfo(CRYPT_OID_INFO_NAME_KEY, keeper.keyName,
755              CRYPT_RDN_ATTR_OID_GROUP_ID);
756             if (!keyOID)
757             {
758                 if (ppszError)
759                     *ppszError = token.start;
760                 error = CRYPT_E_INVALID_X500_STRING;
761             }
762             else
763             {
764                 str = token.end;
765                 while (isspace(*str))
766                     str++;
767                 if (*str != '=')
768                 {
769                     if (ppszError)
770                         *ppszError = str;
771                     error = CRYPT_E_INVALID_X500_STRING;
772                 }
773                 else
774                 {
775                     static const WCHAR commaSep[] = { ',',0 };
776                     static const WCHAR semiSep[] = { ';',0 };
777                     static const WCHAR crlfSep[] = { '\r','\n',0 };
778                     static const WCHAR allSeps[] = { ',',';','\r','\n',0 };
779                     LPCWSTR sep;
780
781                     str++;
782                     if (dwStrType & CERT_NAME_STR_COMMA_FLAG)
783                         sep = commaSep;
784                     else if (dwStrType & CERT_NAME_STR_SEMICOLON_FLAG)
785                         sep = semiSep;
786                     else if (dwStrType & CERT_NAME_STR_CRLF_FLAG)
787                         sep = crlfSep;
788                     else
789                         sep = allSeps;
790                     error = CRYPT_GetNextValueW(str, dwStrType, sep, &token,
791                      ppszError);
792                     if (!error)
793                     {
794                         str = token.end;
795                         ret = CRYPT_ValueToRDN(dwCertEncodingType, &info,
796                          keyOID, &token, ppszError);
797                     }
798                 }
799             }
800         }
801     }
802     CRYPT_FreeKeynameKeeper(&keeper);
803     if (!error)
804     {
805         ret = CryptEncodeObjectEx(dwCertEncodingType, X509_NAME, &info,
806          0, NULL, pbEncoded, pcbEncoded);
807         for (i = 0; i < info.cRDN; i++)
808         {
809             DWORD j;
810
811             for (j = 0; j < info.rgRDN[i].cRDNAttr; j++)
812                 LocalFree(info.rgRDN[i].rgRDNAttr[j].Value.pbData);
813             CryptMemFree(info.rgRDN[i].rgRDNAttr);
814         }
815         CryptMemFree(info.rgRDN);
816     }
817     else
818     {
819         SetLastError(error);
820         ret = FALSE;
821     }
822     return ret;
823 }
824
825 DWORD WINAPI CertGetNameStringA(PCCERT_CONTEXT pCertContext, DWORD dwType,
826  DWORD dwFlags, void *pvTypePara, LPSTR pszNameString, DWORD cchNameString)
827 {
828     DWORD ret;
829
830     TRACE("(%p, %d, %08x, %p, %p, %d)\n", pCertContext, dwType, dwFlags,
831      pvTypePara, pszNameString, cchNameString);
832
833     if (pszNameString)
834     {
835         LPWSTR wideName;
836         DWORD nameLen;
837
838         nameLen = CertGetNameStringW(pCertContext, dwType, dwFlags, pvTypePara,
839          NULL, 0);
840         wideName = CryptMemAlloc(nameLen * sizeof(WCHAR));
841         if (wideName)
842         {
843             CertGetNameStringW(pCertContext, dwType, dwFlags, pvTypePara,
844              wideName, nameLen);
845             nameLen = WideCharToMultiByte(CP_ACP, 0, wideName, nameLen,
846              pszNameString, cchNameString, NULL, NULL);
847             if (nameLen <= cchNameString)
848                 ret = nameLen;
849             else
850             {
851                 pszNameString[cchNameString - 1] = '\0';
852                 ret = cchNameString;
853             }
854             CryptMemFree(wideName);
855         }
856         else
857         {
858             *pszNameString = '\0';
859             ret = 1;
860         }
861     }
862     else
863         ret = CertGetNameStringW(pCertContext, dwType, dwFlags, pvTypePara,
864          NULL, 0);
865     return ret;
866 }
867
868 DWORD WINAPI CertGetNameStringW(PCCERT_CONTEXT pCertContext, DWORD dwType,
869  DWORD dwFlags, void *pvTypePara, LPWSTR pszNameString, DWORD cchNameString)
870 {
871     DWORD ret;
872     PCERT_NAME_BLOB name;
873     LPCSTR altNameOID;
874
875     TRACE("(%p, %d, %08x, %p, %p, %d)\n", pCertContext, dwType,
876      dwFlags, pvTypePara, pszNameString, cchNameString);
877
878     if (dwFlags & CERT_NAME_ISSUER_FLAG)
879     {
880         name = &pCertContext->pCertInfo->Issuer;
881         altNameOID = szOID_ISSUER_ALT_NAME;
882     }
883     else
884     {
885         name = &pCertContext->pCertInfo->Subject;
886         altNameOID = szOID_SUBJECT_ALT_NAME;
887     }
888
889     switch (dwType)
890     {
891     case CERT_NAME_SIMPLE_DISPLAY_TYPE:
892     {
893         static const LPCSTR simpleAttributeOIDs[] = { szOID_COMMON_NAME,
894          szOID_ORGANIZATIONAL_UNIT_NAME, szOID_ORGANIZATION_NAME,
895          szOID_RSA_emailAddr };
896         CERT_NAME_INFO *info = NULL;
897         PCERT_RDN_ATTR nameAttr = NULL;
898         DWORD bytes = 0, i;
899
900         if (CryptDecodeObjectEx(pCertContext->dwCertEncodingType, X509_NAME,
901          name->pbData, name->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &info,
902          &bytes))
903         {
904             for (i = 0; !nameAttr && i < sizeof(simpleAttributeOIDs) /
905              sizeof(simpleAttributeOIDs[0]); i++)
906                 nameAttr = CertFindRDNAttr(simpleAttributeOIDs[i], info);
907         }
908         if (!nameAttr)
909         {
910             PCERT_EXTENSION ext = CertFindExtension(altNameOID,
911              pCertContext->pCertInfo->cExtension,
912              pCertContext->pCertInfo->rgExtension);
913
914             if (ext)
915             {
916                 for (i = 0; !nameAttr && i < sizeof(simpleAttributeOIDs) /
917                  sizeof(simpleAttributeOIDs[0]); i++)
918                     nameAttr = CertFindRDNAttr(simpleAttributeOIDs[i], info);
919                 if (!nameAttr)
920                 {
921                     /* FIXME: gotta then look for a rfc822Name choice in ext.
922                      * Failing that, look for the first attribute.
923                      */
924                     FIXME("CERT_NAME_SIMPLE_DISPLAY_TYPE: stub\n");
925                 }
926             }
927         }
928         if (nameAttr)
929             ret = CertRDNValueToStrW(nameAttr->dwValueType, &nameAttr->Value,
930                                      pszNameString, cchNameString);
931         else
932             ret = 0;
933         if (info)
934             LocalFree(info);
935         break;
936     }
937     case CERT_NAME_FRIENDLY_DISPLAY_TYPE:
938     {
939         DWORD cch = cchNameString;
940
941         if (CertGetCertificateContextProperty(pCertContext,
942          CERT_FRIENDLY_NAME_PROP_ID, pszNameString, &cch))
943             ret = cch;
944         else
945             ret = CertGetNameStringW(pCertContext,
946              CERT_NAME_SIMPLE_DISPLAY_TYPE, dwFlags, pvTypePara, pszNameString,
947              cchNameString);
948         break;
949     }
950     default:
951         FIXME("unimplemented for type %d\n", dwType);
952         ret = 0;
953     }
954     return ret;
955 }