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