1 /* { dg-do compile } */
2 /* { dg-options "-O -w -fdump-tree-dse1-vops" } */
3
4 __extension__ typedef __SIZE_TYPE__ size_t;
5 typedef struct _IO_FILE FILE;
6 typedef struct
7 {
8 } __mbstate_t;
9 typedef struct
10 {
11 } _G_fpos_t;
12 typedef struct
13 {
14 };
15 typedef int (*__gconv_trans_fct) (struct __gconv_step *,
16 size_t *);
17 typedef int (*__gconv_trans_context_fct) (void *, __const unsigned char *,
18 size_t *);
19 struct __gconv_trans_data
20 {
21 };
22 struct __gconv_step_data
23 {
24 };
25 typedef struct __gconv_info
26 {
27 } *__gconv_t;
28 typedef union
29 {
30 struct
31 {
32 } __combined;
33 } _G_iconv_t;
34 typedef __builtin_va_list __gnuc_va_list;
35 enum __codecvt_result
36 {
37 __codecvt_noconv
38 };
39 struct _IO_FILE {
40 };
41 vprintf (__const char *__restrict __fmt, __gnuc_va_list __arg)
42 {
43 }
44 putchar (int __c)
45 {
46 }
47 fputc_unlocked (int __c, FILE *__stream)
48 {
49 }
50 putc_unlocked (int __c, FILE *__stream)
51 {
52 }
53 __attribute__ ((__nothrow__)) ferror_unlocked (FILE *__stream)
54 {
55 }
56 extern int __sprintf_chk (char *__restrict __s, int __flag, size_t __slen,
57 __gnuc_va_list __ap);
58 gets (char *__str)
59 {
60 }
61 extern char *__fgets_chk (char *__restrict __s, size_t __size, int __n,
62 FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
63 fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
64 {
65 }
66 typedef void *LPVOID;
67 typedef int BOOL, *PBOOL, *LPBOOL;
68 typedef unsigned char BYTE, *PBYTE, *LPBYTE;
69 typedef unsigned short WORD, *PWORD, *LPWORD;
70 typedef unsigned int DWORD, *PDWORD, *LPDWORD;
71 typedef struct _GUID
72 {
73 } GUID;
74 enum
75 {
76 _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
77 };
78 extern char *__strtok_r (char *__restrict __s,
79 __const char *__restrict __delim,
80 char **__restrict __save_ptr)
81 __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
82 __strcspn_c3 (__const char *__s, int __reject1, int __reject2,
83 int __reject3)
84 {
85 }
86 extern __inline size_t __strspn_c3 (__const char *__s, int __accept1,
87 int __accept2, int __accept3);
88 extern __inline size_t
89 __strspn_c3 (__const char *__s, int __accept1, int __accept2, int __accept3)
90 {
91 }
92 extern __inline char *__strpbrk_c2 (__const char *__s, int __accept1,
93 int __accept2);
94 extern __inline char *
95 __strpbrk_c2 (__const char *__s, int __accept1, int __accept2)
96 {
97 }
98 extern __inline char *__strpbrk_c3 (__const char *__s, int __accept1,
99 int __accept3)
100 {
101 }
102 __strtok_r_1c (char *__s, char __sep, char **__nextp)
103 {
104 {
105 {
106 }
107 }
108 }
109 __strsep_1c (char **__s, char __reject)
110 {
111 }
112 __strsep_2c (char **__s, char __reject1, char __reject2)
113 {
114 {
115 {
116 }
117 }
118 }
119 extern __inline char *__strsep_3c (char **__s, char __reject1, char __reject2,
120 char __reject3);
121 extern __inline char *
122 __strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
123 {
124 {
125 {
126 {
127 }
128 }
129 }
130 }
131 __attribute__ ((__nothrow__)) __memcpy_ichk (void *__restrict __dest, __const void *__restrict __src, size_t __len)
132 {
133 }
134 __attribute__ ((__nothrow__)) __memmove_ichk (void *__dest, __const void *__src, size_t __len)
135 {
136 }
137 __attribute__ ((__nothrow__)) __strncpy_ichk (char *__restrict __dest, __const char *__restrict __src, size_t __len)
138 {
139 }
140 __attribute__ ((__nothrow__)) stpncpy (char *__dest, __const char *__src, size_t __n)
141 {
142 if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1
143 && (!__builtin_constant_p (__n) || __n <= __builtin_object_size (__dest, 2 > 1)))
144 return __stpncpy_chk (__dest, __src, __n, __builtin_object_size (__dest, 2 > 1));
145 }
146 __attribute__ ((__nothrow__)) __strncat_ichk (char *__restrict __dest, __const char *__restrict __src, size_t __len)
147 {
148 }
149 typedef void *PVOID;
150 typedef char CHAR, *PCHAR;
151 typedef int LONG, *PLONG;
152 typedef unsigned short WCHAR, *PWCHAR;
153 typedef CHAR *PSTR, *LPSTR, *NPSTR;
154 typedef const CHAR *PCSTR, *LPCSTR;
155 typedef WCHAR *PWSTR, *LPWSTR, *NWPSTR;
156 typedef LONG HRESULT;
157 typedef struct _MEMORY_BASIC_INFORMATION
158 {
159 } SINGLE_LIST_ENTRY, *PSINGLE_LIST_ENTRY;
160 typedef enum _HEAP_INFORMATION_CLASS {
161 HeapCompatibilityInformation,
162 } HEAP_INFORMATION_CLASS;
163 typedef struct _FLOATING_SAVE_AREA
164 {
165 } CONTEXT86;
166 typedef struct _LDT_ENTRY {
167 union {
168 struct {
169 } Bits;
170 } HighWord;
171 } LDT_ENTRY, *PLDT_ENTRY;
172 typedef struct _EXCEPTION_RECORD
173 {
174 } EXCEPTION_RECORD, *PEXCEPTION_RECORD;
175 typedef struct _EXCEPTION_POINTERS
176 {
177 } EXCEPTION_POINTERS, *PEXCEPTION_POINTERS;
178 typedef struct _NT_TIB
179 {
180 union {
181 } ;
182 } NT_TIB, *PNT_TIB;
183 extern inline struct _TEB * __attribute__((__stdcall__)) NtCurrentTeb(void)
184 {
185 } IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;
186 typedef struct _IMAGE_SYMBOL {
187 union {
188 struct {
189 } FcnAry;
190 } Section;
191 } IMAGE_AUX_SYMBOL;
192 typedef struct _IMAGE_EXPORT_DIRECTORY {
193 union {
194 } u1;
195 } IMAGE_BOUND_FORWARDER_REF, *PIMAGE_BOUND_FORWARDER_REF;
196 typedef struct _IMAGE_BASE_RELOCATION
197 {
198 } IMAGE_BASE_RELOCATION,*PIMAGE_BASE_RELOCATION;
199 typedef struct _IMAGE_RELOCATION
200 {
201 union {
202 } ;
203 } IMAGE_RELOCATION, *PIMAGE_RELOCATION;
204 typedef struct _IMAGE_ARCHIVE_MEMBER_HEADER
205 {
206 } IMAGE_RESOURCE_DIRECTORY,*PIMAGE_RESOURCE_DIRECTORY;
207 typedef struct _IMAGE_RESOURCE_DIRECTORY_ENTRY {
208 union {
209 struct {
210 } ;
211 struct {
212 } ;
213 } ;
214 } IMAGE_DEBUG_DIRECTORY, *PIMAGE_DEBUG_DIRECTORY;
215 typedef enum ReplacesCorHdrNumericDefines
216 {
217 MAX_PACKAGE_NAME = 1024,
218 } ReplacesCorHdrNumericDefines;
219 typedef struct IMAGE_COR20_HEADER
220 {
221 } MESSAGE_RESOURCE_DATA,*PMESSAGE_RESOURCE_DATA;
222 typedef PVOID PSECURITY_DESCRIPTOR;
223 typedef enum _TOKEN_INFORMATION_CLASS {
224 TokenUser = 1,
225 } TOKEN_INFORMATION_CLASS;
226 typedef struct _GENERIC_MAPPING {
227 } ACL, *PACL;
228 typedef struct _ACL_SIZE_INFORMATION
229 {
230 } ACL_SIZE_INFORMATION, *PACL_SIZE_INFORMATION;
231 typedef WORD SECURITY_DESCRIPTOR_CONTROL, *PSECURITY_DESCRIPTOR_CONTROL;
232 typedef struct {
233 } SID_AND_ATTRIBUTES;
234 typedef enum {
235 WinBuiltinTerminalServerLicenseServersSid = 60
236 } WELL_KNOWN_SID_TYPE;
237 typedef struct _TOKEN_USER {
238 } TOKEN_GROUPS, *PTOKEN_GROUPS;
239 typedef union _LARGE_INTEGER {
240 struct {
241 };
242 } LARGE_INTEGER, *PLARGE_INTEGER;
243 typedef union _ULARGE_INTEGER {
244 struct {
245 };
246 } LUID, *PLUID;
247 typedef struct _LUID_AND_ATTRIBUTES {
248 } LUID_AND_ATTRIBUTES, *PLUID_AND_ATTRIBUTES;
249 typedef enum tagTOKEN_TYPE {
250 TokenPrimary = 1,
251 } SECURITY_IMPERSONATION_LEVEL, *PSECURITY_IMPERSONATION_LEVEL;
252 typedef struct _SECURITY_QUALITY_OF_SERVICE {
253 } QUOTA_LIMITS_EX, *PQUOTA_LIMITS_EX;
254 typedef enum _LATENCY_TIME {
255 VerifyProcessorPowerPolicyDc,
256 } POWER_INFORMATION_LEVEL;
257 typedef struct _ADMINISTRATOR_POWER_POLICY {
258 } RTL_CRITICAL_SECTION_DEBUG, *PRTL_CRITICAL_SECTION_DEBUG, RTL_RESOURCE_DEBUG, *PRTL_RESOURCE_DEBUG;
259 typedef struct _RTL_CRITICAL_SECTION {
260 } RTL_CRITICAL_SECTION, *PRTL_CRITICAL_SECTION;
261 typedef struct _IO_COUNTERS {
262 } OSVERSIONINFOA, *POSVERSIONINFOA, *LPOSVERSIONINFOA;
263 typedef struct {
264 } OSVERSIONINFOW, *POSVERSIONINFOW, *LPOSVERSIONINFOW, RTL_OSVERSIONINFOW, *PRTL_OSVERSIONINFOW;
265 typedef struct {
266 } OSVERSIONINFOEXA, *POSVERSIONINFOEXA, *LPOSVERSIONINFOEXA;
267 typedef struct {
268 } OSVERSIONINFOEXW, *POSVERSIONINFOEXW, *LPOSVERSIONINFOEXW, RTL_OSVERSIONINFOEXW, *PRTL_OSVERSIONINFOEXW;
269 typedef struct tagSIZE
270 {
271 } POINT, *PPOINT, *LPPOINT;
272 typedef struct _POINTL
273 {
274 } FILETIME, *PFILETIME, *LPFILETIME;
275 typedef struct tagRECT
276 {
277 } ldiv_t;
278 extern double strtod (__const char *__restrict __nptr,
279 char **__restrict __endptr)
280 __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
281 extern long int strtol (__const char *__restrict __nptr,
282 char **__restrict __endptr, int __base)
283 __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
284 extern long int __strtol_internal (__const char *__restrict __nptr,
285 int __base, int __group)
286 __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
287 extern unsigned long int __strtoul_internal (__const char *__restrict __nptr,
288 int __base, int __group)
289 __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
290 extern __inline double
291 __attribute__ ((__nothrow__)) strtod (__const char *__restrict __nptr, char **__restrict __endptr)
292 {
293 }
294 extern __inline long int
295 __attribute__ ((__nothrow__)) strtol (__const char *__restrict __nptr, char **__restrict __endptr, int __base)
296 {
297 }
298 __attribute__ ((__nothrow__)) strtoll (__const char *__restrict __nptr, char **__restrict __endptr, int __base)
299 {
300 }
301 __attribute__ ((__nothrow__)) atoi (__const char *__nptr)
302 {
303 }
304 typedef int int32_t __attribute__ ((__mode__ (__SI__)));
305 typedef struct
306 {
307 };
308 extern int random_r (struct random_data *__restrict __buf,
309 int32_t *__restrict __result) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
310 struct drand48_data
311 {
312 };
313 extern int drand48_r (struct drand48_data *__restrict __buffer,
314 long int *__restrict __result)
315 __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
316 extern int mrand48_r (struct drand48_data *__restrict __buffer,
317 long int *__restrict __result)
318 __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
319 extern int jrand48_r (unsigned short int __xsubi[3],
320 long int *__restrict __result)
321 __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
322 extern int seed48_r (unsigned short int __seed16v[3],
323 struct drand48_data *__buffer) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
324 extern char *qfcvt (long double __value, int __ndigit,
325 size_t __resolvedlen) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));
326 __attribute__ ((__nothrow__)) realpath (__const char *__restrict __name, char *__restrict __resolved)
327 {
328 }
329 __attribute__ ((__nothrow__)) ptsname_r (int __fd, char *__buf, size_t __buflen)
330 {
331 }
332 typedef struct _EXCEPTION_DEBUG_INFO {
333 } EXCEPTION_DEBUG_INFO;
334 typedef struct _CREATE_THREAD_DEBUG_INFO {
335 } CREATE_THREAD_DEBUG_INFO;
336 typedef struct _CREATE_PROCESS_DEBUG_INFO {
337 } CREATE_PROCESS_DEBUG_INFO;
338 typedef struct _EXIT_THREAD_DEBUG_INFO {
339 } LOAD_DLL_DEBUG_INFO;
340 typedef struct _UNLOAD_DLL_DEBUG_INFO {
341 } RIP_INFO;
342 typedef struct _DEBUG_EVENT {
343 union {
344 } u;
345 } DEBUG_EVENT, *LPDEBUG_EVENT;
346 typedef struct _OFSTRUCT
347 {
348 } WIN32_FIND_DATAA, *PWIN32_FIND_DATAA, *LPWIN32_FIND_DATAA;
349 typedef struct _WIN32_FIND_DATAW
350 {
351 } WIN32_FIND_DATAW, *PWIN32_FIND_DATAW, *LPWIN32_FIND_DATAW;
352 typedef enum _FINDEX_SEARCH_OPS
353 {
354 FindExSearchNameMatch,
355 } FINDEX_SEARCH_OPS;
356 typedef struct _PROCESS_HEAP_ENTRY
357 {
358 union {
359 struct {
360 } Block;
361 struct {
362 } Region;
363 } ;
364 } PROCESS_HEAP_ENTRY, *PPROCESS_HEAP_ENTRY, *LPPROCESS_HEAP_ENTRY;
365 typedef struct tagMEMORYSTATUS
366 {
367 } MEMORYSTATUSEX, *LPMEMORYSTATUSEX;
368 typedef struct _SYSTEMTIME{
369 WORD wYear;
370 } SYSTEMTIME, *PSYSTEMTIME, *LPSYSTEMTIME;
371 typedef struct _OVERLAPPED {
372 union {
373 struct {
374 } ;
375 } ;
376 } PROCESS_INFORMATION, *PPROCESS_INFORMATION, *LPPROCESS_INFORMATION;
377 typedef struct _TIME_ZONE_INFORMATION{
378 } TIME_ZONE_INFORMATION, *PTIME_ZONE_INFORMATION, *LPTIME_ZONE_INFORMATION;
379 typedef struct _BY_HANDLE_FILE_INFORMATION
380 {
381 } ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, *PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
382 typedef struct tagACTCTX_SECTION_KEYED_DATA {
383 } COMMTIMEOUTS,*LPCOMMTIMEOUTS;
384 typedef enum _COMPUTER_NAME_FORMAT
385 {
386 ComputerNameNetBIOS,
387 } COMPUTER_NAME_FORMAT;
388 typedef struct tagHW_PROFILE_INFOA {
389 } HW_PROFILE_INFOA, *LPHW_PROFILE_INFOA;
390 typedef struct tagHW_PROFILE_INFOW {
391 } HW_PROFILE_INFOW, *LPHW_PROFILE_INFOW;
392 BOOL __attribute__((__stdcall__)) SetSecurityDescriptorControl(PSECURITY_DESCRIPTOR,SECURITY_DESCRIPTOR_CONTROL,
393 SECURITY_DESCRIPTOR_CONTROL);
394 typedef struct tagSYSLEVEL
395 {
396 } SYSLEVEL;
397 static inline PVOID __attribute__((__stdcall__)) InterlockedCompareExchangePointer( PVOID volatile *dest, PVOID xchg, PVOID compare )
398 {
399 }
400 static inline PVOID __attribute__((__stdcall__)) InterlockedExchangePointer( PVOID volatile *dest, PVOID val )
401 {
402 }
403 typedef unsigned long HCRYPTPROV;
404 typedef unsigned long HCRYPTKEY;
405 typedef void *HCERTSTOREPROV;
406 typedef struct _PROV_ENUMALGS {
407 } PROV_ENUMALGS;
408 typedef struct _HMAC_INFO {
409 } HMAC_INFO, *PHMAC_INFO;
410 typedef struct _CRYPTOAPI_BLOB {
411 DWORD cbData;
412 BYTE* pbData;
413 } CRYPT_INTEGER_BLOB, *PCRYPT_INTEGER_BLOB,
414 CRYPT_OBJID_BLOB, *PCRYPT_OBJID_BLOB,
415 CERT_NAME_BLOB, *PCERT_NAME_BLOB,
416 CERT_RDN_VALUE_BLOB, *PCERT_RDN_VALUE_BLOB,
417 CRYPT_DER_BLOB, *PCRYPT_DER_BLOB,
418 CRYPT_ATTR_BLOB, *PCRYPT_ATTR_BLOB;
419 typedef struct _CRYPTPROTECT_PROMPTSTRUCT{
420 } CRYPTPROTECT_PROMPTSTRUCT, *PCRYPTPROTECT_PROMPTSTRUCT;
421 typedef struct _CRYPT_ALGORITHM_IDENTIFIER {
422 LPSTR pszObjId;
423 CRYPT_OBJID_BLOB Parameters;
424 } CRYPT_ALGORITHM_IDENTIFIER, *PCRYPT_ALGORITHM_IDENTIFIER;
425 typedef struct _CRYPT_ATTRIBUTE_TYPE_VALUE {
426 } CRYPT_ATTRIBUTE_TYPE_VALUE, *PCRYPT_ATTRIBUTE_TYPE_VALUE;
427 typedef struct _PUBLICKEYSTRUC {
428 } BLOBHEADER, PUBLICKEYSTRUC;
429 typedef struct _RSAPUBKEY {
430 DWORD magic;
431 DWORD pubexp;
432 } RSAPUBKEY;
433 typedef struct _CRYPT_BIT_BLOB {
434 DWORD cbData;
435 BYTE *pbData;
436 DWORD cUnusedBits;
437 } CRYPT_BIT_BLOB, *PCRYPT_BIT_BLOB;
438 typedef struct _CRYPT_KEY_PROV_PARAM {
439 } CRYPT_KEY_PROV_PARAM, *PCRYPT_KEY_PROV_PARAM;
440 typedef struct _CRYPT_KEY_PROV_INFO {
441 CRYPT_ALGORITHM_IDENTIFIER Algorithm;
442 CRYPT_BIT_BLOB PublicKey;
443 } CERT_PUBLIC_KEY_INFO, *PCERT_PUBLIC_KEY_INFO;
444 typedef struct _CERT_EXTENSION {
445 LPSTR pszObjId;
446 CRYPT_OBJID_BLOB Value;
447 } CERT_EXTENSION, *PCERT_EXTENSION;
448 typedef struct _CERT_EXTENSIONS {
449 DWORD cExtension;
450 PCERT_EXTENSION rgExtension;
451 } CERT_EXTENSIONS, *PCERT_EXTENSIONS;
452 typedef struct _CERT_INFO {
453 CRYPT_INTEGER_BLOB SerialNumber;
454 CERT_NAME_BLOB Subject;
455 CERT_PUBLIC_KEY_INFO SubjectPublicKeyInfo;
456 } CERT_INFO, *PCERT_INFO;
457 typedef struct _CERT_RDN_ATTR {
458 LPSTR pszObjId;
459 CERT_RDN_VALUE_BLOB Value;
460 } CERT_RDN_ATTR, *PCERT_RDN_ATTR;
461 typedef struct _CERT_RDN {
462 } CERT_RDN, *PCERT_RDN;
463 typedef struct _CERT_NAME_INFO {
464 DWORD cRDN;
465 } CERT_NAME_INFO, *PCERT_NAME_INFO;
466 typedef struct _CERT_NAME_VALUE {
467 DWORD dwValueType;
468 CERT_RDN_VALUE_BLOB Value;
469 } CERT_NAME_VALUE, *PCERT_NAME_VALUE;
470 typedef struct _CERT_ENCRYPTED_PRIVATE_KEY_INFO {
471 CERT_NAME_BLOB CertIssuer;
472 } CERT_AUTHORITY_KEY_ID_INFO, *PCERT_AUTHORITY_KEY_ID_INFO;
473 typedef struct _CERT_PRIVATE_KEY_VALIDITY {
474 } CERT_OTHER_NAME, *PCERT_OTHER_NAME;
475 typedef struct _CERT_ALT_NAME_ENTRY {
476 DWORD dwAltNameChoice;
477 union {
478 LPWSTR pwszURL;
479 } ;
480 } CERT_ALT_NAME_ENTRY, *PCERT_ALT_NAME_ENTRY;
481 typedef struct _CERT_ALT_NAME_INFO {
482 DWORD cAltEntry;
483 PCERT_ALT_NAME_ENTRY rgAltEntry;
484 } CERT_ALT_NAME_INFO, *PCERT_ALT_NAME_INFO;
485 typedef struct _CERT_BASIC_CONSTRAINTS_INFO {
486 CERT_NAME_BLOB *rgSubtreesConstraint;
487 } CERT_BASIC_CONSTRAINTS_INFO, *PCERT_BASIC_CONSTRAINTS_INFO;
488 typedef struct _CERT_BASIC_CONSTRAINTS2_INFO {
489 } CERT_BASIC_CONSTRAINTS2_INFO, *PCERT_BASIC_CONSTRAINTS2_INFO;
490 typedef struct _CERT_POLICY_QUALIFIER_INFO {
491 } CERT_POLICY_QUALIFIER_INFO, *PCERT_POLICY_QUALIFIER_INFO;
492 typedef struct _CERT_POLICY_QUALIFIER_NOTICE_REFERENCE {
493 } CERT_POLICY_QUALIFIER_NOTICE_REFERENCE,
494 *PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE;
495 typedef struct _CERT_POLICY_QUALIFIER_USER_NOTICE {
496 DWORD cValue;
497 PCRYPT_DER_BLOB rgValue;
498 } CRYPT_SEQUENCE_OF_ANY, *PCRYPT_SEQUENCE_OF_ANY;
499 typedef struct _CERT_AUTHORITY_KEY_ID2_INFO {
500 PCERT_INFO pCertInfo;
501 } CERT_CONTEXT, *PCERT_CONTEXT;
502 typedef const CERT_CONTEXT *PCCERT_CONTEXT;
503 typedef struct _CRL_ENTRY {
504 } CRL_ENTRY, *PCRL_ENTRY;
505 typedef struct _CRL_INFO {
506 DWORD cCRLEntry;
507 DWORD cExtension;
508 } CRL_INFO, *PCRL_INFO;
509 typedef struct _CRL_DIST_POINT_NAME {
510 DWORD dwDistPointNameChoice;
511 union {
512 } ;
513 } CRL_DIST_POINT_NAME, *PCRL_DIST_POINT_NAME;
514 typedef struct _CRL_DIST_POINT {
515 CRL_DIST_POINT_NAME DistPointName;
516 CRYPT_BIT_BLOB ReasonFlags;
517 CERT_ALT_NAME_INFO CRLIssuer;
518 } CRL_DIST_POINT, *PCRL_DIST_POINT;
519 typedef struct _CRL_DIST_POINTS_INFO {
520 DWORD cDistPoint;
521 PCRL_DIST_POINT rgDistPoint;
522 } CRL_DIST_POINTS_INFO, *PCRL_DIST_POINTS_INFO;
523 typedef struct _CRL_ISSUING_DIST_POINT {
524 BOOL fOnlyContainsUserCerts;
525 } CRL_ISSUING_DIST_POINT, *PCRL_ISSUING_DIST_POINT;
526 typedef struct _CERT_GENERAL_SUBTREE {
527 } CRYPT_ATTRIBUTE, *PCRYPT_ATTRIBUTE;
528 typedef struct _CRYPT_ATTRIBUTES {
529 } CRYPT_ATTRIBUTES, *PCRYPT_ATTRIBUTES;
530 typedef struct _CERT_REQUEST_INFO {
531 DWORD dwVersion;
532 CRYPT_ALGORITHM_IDENTIFIER SignatureAlgorithm;
533 CRYPT_BIT_BLOB Signature;
534 } CERT_SIGNED_CONTENT_INFO, *PCERT_SIGNED_CONTENT_INFO;
535 typedef struct _CRL_CONTEXT {
536 } CRL_CONTEXT, *PCRL_CONTEXT;
537 typedef struct _VTableProvStruc {
538 } CTL_CONTEXT, *PCTL_CONTEXT;
539 typedef struct _CRYPT_TIME_STAMP_REQUEST_INFO {
540 } CERT_REVOCATION_STATUS, *PCERT_REVOCATION_STATUS;
541 typedef struct _CERT_TRUST_STATUS {
542 } CERT_SYSTEM_STORE_RELOCATE_PARA, *PCERT_SYSTEM_STORE_RELOCATE_PARA;
543 typedef BOOL (__attribute__((__stdcall__)) *PFN_CERT_ENUM_SYSTEM_STORE_LOCATION)(
544 void *pvArg);
545 typedef struct _CRYPT_ENCODE_PARA {
546 } CERT_STORE_PROV_INFO, *PCERT_STORE_PROV_INFO;
547 typedef BOOL (__attribute__((__stdcall__)) *PFN_CERT_DLL_OPEN_STORE_PROV_FUNC)(
548 DWORD dwFlags, DWORD dwCtrlType, void const *pvCtrlPara);
549 typedef struct _CERT_STORE_PROV_FIND_INFO {
550 } CERT_STORE_PROV_FIND_INFO, *PCERT_STORE_PROV_FIND_INFO;
551 typedef BOOL (__attribute__((__stdcall__)) *PFN_CERT_STORE_PROV_FIND_CERT)(HCERTSTOREPROV hStoreProv,
552 DWORD dwFlags, void **ppvStoreProvFindInfo, PCCERT_CONTEXT *ppProvCertContext);
553 typedef BOOL (__attribute__((__stdcall__)) *PFN_CERT_STORE_PROV_FREE_FIND_CERT)(
554 DWORD dwFlags, void *pvData, DWORD *pcbData);
555 typedef BOOL (__attribute__((__stdcall__)) *PFN_CERT_STORE_PROV_GET_CTL_PROPERTY)(
556 DWORD dwFlags, void *pvData);
557 typedef struct _CERT_CREATE_CONTEXT_PARA {
558 } CRYPT_OID_FUNC_ENTRY, *PCRYPT_OID_FUNC_ENTRY;
559 typedef BOOL (__attribute__((__stdcall__)) *PFN_CRYPT_ENUM_OID_FUNC)(DWORD dwEncodingType,
560 const DWORD rgcbValueData[], void *pvArg);
561 typedef struct _CRYPT_OID_INFO {
562 union {
563 } ;
564 } CRYPT_OID_INFO, *PCRYPT_OID_INFO;
565 typedef const CRYPT_OID_INFO CCRYPT_OID_INFO, *PCCRYPT_OID_INFO;
566 typedef BOOL (__attribute__((__stdcall__)) *PFN_CRYPT_ENUM_OID_INFO)(PCCRYPT_OID_INFO pInfo,
567 void *pvArg);
568 typedef struct _CRYPT_SIGN_MESSAGE_PARA {
569 } CRYPT_HASH_MESSAGE_PARA, *PCRYPT_HASH_MESSAGE_PARA;
570 typedef struct _CRYPT_KEY_SIGN_MESSAGE_PARA {
571 } CRYPT_URL_INFO, *PCRYPT_URL_INFO;
572 typedef void (__attribute__((__stdcall__)) *PFN_CRYPT_ASYNC_PARAM_FREE_FUNC)(LPSTR pszParamOid,
573 LPVOID pvParam);
574 typedef struct _CRYPT_CREDENTIALS {
575 } CRYPT_CREDENTIALS, *PCRYPT_CREDENTIALS;
576 typedef struct _CRYPT_PASSWORD_CREDENTIALSA {
577 } CRYPT_PASSWORD_CREDENTIALSW, *PCRYPT_PASSWORD_CREDENTIALSW;
578 typedef struct _CRYPT_RETRIEVE_AUX_INFO {
579 } CRYPT_RETRIEVE_AUX_INFO, *PCRYPT_RETRIEVE_AUX_INFO;
580 typedef struct _CERT_CHAIN_ENGINE_CONFIG
581 {
582 } CERT_CHAIN_ENGINE_CONFIG, *PCERT_CHAIN_ENGINE_CONFIG;
583 BOOL __attribute__((__stdcall__)) CryptExportPublicKeyInfoEx(HCRYPTPROV hCryptProv, DWORD dwKeySpec,
584 DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId, DWORD dwFlags,
585 void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo);
586 BOOL __attribute__((__stdcall__)) CryptImportPublicKeyInfo(HCRYPTPROV hCryptProv,
587 PCRYPT_RETRIEVE_AUX_INFO pAuxInfo);
588 struct encodedInt
589 {
590 int val;
591 const BYTE *encoded;
592 };
593 static const struct encodedInt ints[] = {
594 };
595 struct encodedBigInt
596 {
597 const BYTE *val;
598 const BYTE *encoded;
599 };
600 static const struct encodedBigInt bigInts[] = {
601 };
602 static const struct encodedBigInt bigUInts[] = {
603 };
604 static void test_encodeInt(DWORD dwEncoding)
605 {
606 DWORD bufSize = 0;
607 int i;
608 BOOL ret;
609 CRYPT_INTEGER_BLOB blob;
610 BYTE *buf = ((void *)0);
611 ret = CryptEncodeObjectEx(0, ((LPCSTR)27), &ints[0].val, 0, ((void *)0), ((void *)0),
612 "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
613 {
614 ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)27), &ints[i].val,
615 0x08000, ((void *)0), &buf, &bufSize);
616 {
617 (winetest_set_location("encode.c", 119), 0) ? 0 : winetest_ok(buf[0] == 2, "Got unexpected type %d for integer (expected 2)\n",
618 buf[1], ints[i].encoded[1]);
619 }
620 ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)28), &blob,
621 0, ((void *)0), ((void *)0), &bufSize);
622 {
623 }
624 ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)38), &blob,
625 0x08000, ((void *)0), &buf, &bufSize);
626 {
627 (winetest_set_location("encode.c", 187), 0) ? 0 : winetest_ok(buf[1] == bigUInts[i].encoded[1], "Got length %d, expected %d\n",
628 buf[1], bigUInts[i].encoded[1]);
629 (winetest_set_location("encode.c", 189), 0) ? 0 : winetest_ok(!memcmp(buf + 1, bigUInts[i].encoded + 1,
630 bigUInts[i].encoded[1] + 1),
631 "Encoded value didn't match expected\n");
632 }
633 }
634 }
635 static void test_decodeInt(DWORD dwEncoding)
636 {
637 static const BYTE longForm[] = { 2, 0x81, 0x01, 0x01 };
638 BYTE *buf = ((void *)0);
639 DWORD bufSize = 0;
640 int i;
641 BOOL ret;
642 ret = CryptDecodeObjectEx(3, ((LPCSTR)27), (BYTE *)&ints[0].encoded,
643 ints[0].encoded[1] + 2, 0, ((void *)0), ((void *)0), &bufSize);
644 (winetest_set_location("encode.c", 225), 0) ? 0 : winetest_ok(!ret && GetLastError() == ((HRESULT)0x80093104L),
645 "Expected CRYPT_E_ASN1_BADTAG, got %d\n", GetLastError());
646 {
647 {
648 (winetest_set_location("encode.c", 249), 0) ? 0 : winetest_ok(!memcmp(buf, &ints[i].val, bufSize), "Expected %d, got %d\n",
649 ints[i].val, *(int *)buf);
650 }
651 }
652 {
653 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)28),
654 &bufSize);
655 {
656 CRYPT_INTEGER_BLOB *blob = (CRYPT_INTEGER_BLOB *)buf;
657 (winetest_set_location("encode.c", 296), 0) ? 0 : winetest_ok(blob->cbData == strlen((const char*)bigUInts[i].val),
658 "Unexpected value\n");
659 }
660 }
661 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)28), longForm,
662 sizeof(longForm), 0x08000, ((void *)0), (BYTE *)&buf, &bufSize);
663 {
664 }
665 }
666 static const struct encodedInt enums[] = {
667 };
668 static const LPCSTR enumeratedTypes[] = { ((LPCSTR)29),
669 "2.5.29.21" };
670 static void test_encodeEnumerated(DWORD dwEncoding)
671 {
672 DWORD i, j;
673 {
674 {
675 BOOL ret;
676 DWORD bufSize = 0;
677 ret = CryptEncodeObjectEx(dwEncoding, enumeratedTypes[i],
678 &bufSize);
679 {
680 }
681 }
682 }
683 }
684 static void test_decodeEnumerated(DWORD dwEncoding)
685 {
686 DWORD i, j;
687 {
688 {
689 BOOL ret;
690 DWORD bufSize = sizeof(int);
691 int val;
692 ret = CryptDecodeObjectEx(dwEncoding, enumeratedTypes[i],
693 (BYTE *)&val, &bufSize);
694 (winetest_set_location("encode.c", 403), 0) ? 0 : winetest_ok(val == enums[j].val, "Unexpected value %d, expected %d\n",
695 val, enums[j].val);
696 }
697 }
698 }
699 struct encodedFiletime
700 {
701 SYSTEMTIME sysTime;
702 const BYTE *encodedTime;
703 };
704 static void testTimeEncoding(DWORD dwEncoding, LPCSTR structType,
705 const struct encodedFiletime *time)
706 {
707 }
708 static void testTimeDecoding(DWORD dwEncoding, LPCSTR structType,
709 const struct encodedFiletime *time)
710 {
711 BOOL ret;
712 if (structType == ((LPCSTR)30) ||
713 (time->sysTime.wYear >= 1950 && time->sysTime.wYear <= 2050))
714 {
715 }
716 (winetest_set_location("encode.c", 476), 0) ? 0 : winetest_ok(!ret && GetLastError() == ((HRESULT)0x8009310BL),
717 "Expected CRYPT_E_ASN1_BADTAG, got 0x%08x\n", GetLastError());
718 }
719 static const BYTE bin22[] = {
720 0x18,0x0f,'2','1','4','5','0','6','0','6','1','6','1','0','0','0','Z'};
721 static const struct encodedFiletime times[] = {
722 };
723 static void test_encodeFiletime(DWORD dwEncoding)
724 {
725 {
726 }
727 }
728 static const BYTE bin23[] = {
729 0x18,0x13,'1','9','4','5','0','6','0','6','1','6','1','0','0','0','.','0','0','0','Z'};
730 static const BYTE bin24[] = {
731 0x18,0x13,'1','9','4','5','0','6','0','6','1','6','1','0','0','0','.','9','9','9','Z'};
732 static const BYTE bin26[] = {
733 0x17,0x0b,'4','5','0','6','0','6','1','6','1','0','Z'};
734 static const BYTE bin33[] = {
735 0x17,0x0f,'4','5','0','6','0','6','1','6','1','0','-','0','1','0','0'};
736 static const BYTE bin35[] = {
737 0x17,0x08, '4','5','0','6','0','6','1','6'};
738 static const BYTE bin38[] = {
739 0x18,0x08, '2','1','4','5','0','6','0','6'};
740 static void test_decodeFiletime(DWORD dwEncoding)
741 {
742 static const struct encodedFiletime otherTimes[] = {
743 };
744 static const unsigned char *bogusTimes[] = {
745 };
746 {
747 }
748 }
749 static const char commonName[] = "Juan Lang";
750 static const char surName[] = "Lang";
751 static const BYTE emptySequence[] = { 0x30, 0 };
752 static const BYTE emptyRDNs[] = { 0x30, 0x02, 0x31, 0 };
753 static const BYTE twoRDNs[] = {
754 0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0};
755 static const BYTE encodedTwoRDNs[] = {
756 };
757 static const BYTE us[] = { 0x55, 0x53 };
758 static const BYTE minnesota[] = { 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f,
759 0x6f, 0x6c, 0x69, 0x73 };
760 static const BYTE codeweavers[] = { 0x43, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x61,
761 0x76, 0x65, 0x72, 0x73 };
762 static const BYTE wine[] = { 0x57, 0x69, 0x6e, 0x65, 0x20, 0x44, 0x65, 0x76,
763 0x65, 0x6c, 0x6f, 0x70, 0x6d, 0x65, 0x6e, 0x74 };
764 static const BYTE aric[] = { 0x61, 0x72, 0x69, 0x63, 0x40, 0x63, 0x6f, 0x64,
765 0x65, 0x77, 0x65, 0x61, 0x76, 0x65, 0x72, 0x73, 0x2e, 0x63, 0x6f, 0x6d };
766 static CHAR oid_us[] = "2.5.4.6",
767 oid_aric[] = "1.2.840.113549.1.9.1";
768 static CERT_RDN_ATTR rdnAttrs[] = { { oid_us, 4, { sizeof(us), (LPBYTE)us } },
769 { oid_aric, 7, { sizeof(aric), (LPBYTE)aric } } };
770 static const BYTE encodedRDNAttrs[] = {
771 };
772 static void test_encodeName(DWORD dwEncoding)
773 {
774 CERT_NAME_INFO info;
775 static CHAR oid_common_name[] = "2.5.4.3",
776 oid_sur_name[] = "2.5.4.4";
777 BOOL ret;
778 ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)7), ((void *)0),
779 "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
780 {
781 }
782 ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)7), &info,
783 "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
784 {
785 }
786 {
787 }
788 ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)7), &info,
789 "Expected E_INVALIDARG, got %08x\n", GetLastError());
790 {
791 }
792 }
793 static WCHAR commonNameW[] = { 'J','u','a','n',' ','L','a','n','g',0 };
794 static const BYTE twoRDNsNoNull[] = {
795 0x20,0x4c,0x61,0x6e,0x67 };
796 static const BYTE anyType[] = {
797 0x61,0x4c,0x67,0x6e };
798 static void test_encodeUnicodeName(DWORD dwEncoding)
799 {
800 BOOL ret;
801 ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)20), ((void *)0),
802 "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
803 {
804 }
805 }
806 static void compareNameValues(const CERT_NAME_VALUE *expected,
807 const CERT_NAME_VALUE *got)
808 {
809 (winetest_set_location("encode.c", 913), 0) ? 0 : winetest_ok(got->dwValueType == expected->dwValueType,
810 expected->dwValueType, got->Value.cbData, expected->Value.cbData);
811 (winetest_set_location("encode.c", 920), 0) ? 0 : winetest_ok(!memcmp(got->Value.pbData, expected->Value.pbData,
812 (((got->Value.cbData) < (expected->Value.cbData)) ? (got->Value.cbData) : (expected->Value.cbData))),
813 "String type %d: unexpected value\n", expected->dwValueType);
814 }
815 static void compareRDNAttrs(const CERT_RDN_ATTR *expected,
816 const CERT_RDN_ATTR *got)
817 {
818 {
819 {
820 (winetest_set_location("encode.c", 934), 0) ? 0 : winetest_ok(!__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (got->pszObjId) && __builtin_constant_p (expected->pszObjId) && (__s1_len = strlen (got->pszObjId), __s2_len = strlen (expected->pszObjId), (!((size_t)(const void *)((got->pszObjId) + 1) - (size_t)(const void *)(got->pszObjId) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((expected->pszObjId) + 1) - (size_t)(const void *)(expected->pszObjId) == 1) || __s2_len >= 4)) ? __builtin_strcmp (got->pszObjId, expected->pszObjId) : (__builtin_constant_p (got->pszObjId) && ((size_t)(const void *)((got->pszObjId) + 1) - (size_t)(const void *)(got->pszObjId) == 1) && (__s1_len = strlen (got->pszObjId), __s1_len < 4) ? (__builtin_constant_p (expected->pszObjId) && ((size_t)(const void *)((expected->pszObjId) + 1) - (size_t)(const void *)(expected->pszObjId) == 1) ? __builtin_strcmp (got->pszObjId, expected->pszObjId) : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) (expected->pszObjId); register int __result = (((__const unsigned char *) (__const char *) (got->pszObjId))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (got->pszObjId))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (got->pszObjId))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (got->pszObjId))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (expected->pszObjId) && ((size_t)(const void *)((expected->pszObjId) + 1) - (size_t)(const void *)(expected->pszObjId) == 1) && (__s2_len = strlen (expected->pszObjId), __s2_len < 4) ? (__builtin_constant_p (got->pszObjId) && ((size_t)(const void *)((got->pszObjId) + 1) - (size_t)(const void *)(got->pszObjId) == 1) ? __builtin_strcmp (got->pszObjId, expected->pszObjId) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (got->pszObjId); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) (expected->pszObjId))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) (expected->pszObjId))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) (expected->pszObjId))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (expected->pszObjId))[3]); } } __result; }))) : __builtin_strcmp (got->pszObjId, expected->pszObjId)))); }),
821 expected->pszObjId);
822 }
823 }
824 }
825 static void compareRDNs(const CERT_RDN *expected, const CERT_RDN *got)
826 {
827 {
828 }
829 }
830 static void compareNames(const CERT_NAME_INFO *expected,
831 const CERT_NAME_INFO *got)
832 {
833 (winetest_set_location("encode.c", 959), 0) ? 0 : winetest_ok(got->cRDN == expected->cRDN, "Expected %d RDNs, got %d\n",
834 expected->cRDN, got->cRDN);
835 {
836 }
837 }
838 static void test_decodeName(DWORD dwEncoding)
839 {
840 BYTE *buf = ((void *)0);
841 DWORD bufSize = 0;
842 BOOL ret;
843 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)7), emptySequence,
844 (BYTE *)&buf, &bufSize);
845 {
846 static CHAR oid_sur_name[] = "2.5.4.4",
847 oid_common_name[] = "2.5.4.3";
848 CERT_RDN_ATTR attrs[] = {
849 { oid_sur_name, 4, { sizeof(surName),
850 (BYTE *)commonName } },
851 };
852 }
853 {
854 }
855 }
856 static void test_decodeUnicodeName(DWORD dwEncoding)
857 {
858 BYTE *buf = ((void *)0);
859 DWORD bufSize = 0;
860 BOOL ret;
861 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)20), emptySequence,
862 (BYTE *)&buf, &bufSize);
863 {
864 }
865 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)20), emptyRDNs,
866 (BYTE *)&buf, &bufSize);
867 {
868 }
869 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)20), twoRDNsNoNull,
870 (BYTE *)&buf, &bufSize);
871 {
872 static CHAR oid_sur_name[] = "2.5.4.4",
873 oid_common_name[] = "2.5.4.3";
874 CERT_RDN_ATTR attrs[] = {
875 { oid_sur_name, 4,
876 { lstrlenW(commonNameW) * sizeof(WCHAR), (BYTE *)commonNameW } },
877 };
878 }
879 }
880 struct EncodedNameValue
881 {
882 CERT_NAME_VALUE value;
883 };
884 static const char bogusPrintable[] = "~";
885 static const BYTE bin42[] = { 0x16,0x02,0x80,0x00 };
886 static const BYTE bin43[] = { 0x13,0x02,0x7e,0x00 };
887 static BYTE octetCommonNameValue[] = {
888 0x12,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
889 static BYTE printableCommonNameValue[] = {
890 0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
891 static BYTE t61CommonNameValue[] = {
892 0x14,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
893 static BYTE graphicCommonNameValue[] = {
894 0x61,0x00,0x6e,0x00,0x67,0x00,0x00 };
895 static BYTE utf8CommonNameValue[] = {
896 0x0c,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
897 static struct EncodedNameValue nameValues[] = {
898 { { 5, { sizeof(commonName), (BYTE *)commonName } },
899 sizeof(bin42) },
900 { { 4, { sizeof(bogusPrintable),
901 (BYTE *)bogusPrintable } }, bin43, sizeof(bin43) },
902 };
903 static void test_encodeNameValue(DWORD dwEncoding)
904 {
905 DWORD size = 0, i;
906 BOOL ret;
907 CERT_NAME_VALUE value = { 0, { 0, ((void *)0) } };
908 ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)6), &value,
909 "Expected CRYPT_E_ASN1_CHOICE, got %08x\n", GetLastError());
910 {
911 (winetest_set_location("encode.c", 1209), 0) ? 0 : winetest_ok(size == sizeof(printableCommonNameValue), "Unexpected size %d\n",
912 "Unexpected encoding\n");
913 ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)6),
914 nameValues[i].value.dwValueType, GetLastError());
915 {
916 }
917 }
918 }
919 static void test_decodeNameValue(DWORD dwEncoding)
920 {
921 int i;
922 BYTE *buf = ((void *)0);
923 DWORD bufSize = 0;
924 BOOL ret;
925 {
926 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)6),
927 (BYTE *)&buf, &bufSize);
928 {
929 compareNameValues(&nameValues[i].value,
930 (const CERT_NAME_VALUE *)buf);
931 }
932 }
933 }
934 static const BYTE emptyURL[] = { 0x30, 0x02, 0x86, 0x00 };
935 static const WCHAR url[] = { 'h','t','t','p',':','/','/','w','i','n','e',
936 0x6f, 0x72, 0x67 };
937 static const BYTE encodedIPAddr[] = { 0x30, 0x06, 0x87, 0x04, 0x7f, 0x00, 0x00,
938 0x01 };
939 static void test_encodeAltName(DWORD dwEncoding)
940 {
941 CERT_ALT_NAME_INFO info = { 0 };
942 BYTE *buf = ((void *)0);
943 DWORD size = 0;
944 BOOL ret;
945 ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)12), &info,
946 0x08000, ((void *)0), (BYTE *)&buf, &size);
947 {
948 }
949 {
950 }
951 }
952 static void test_decodeAltName(DWORD dwEncoding)
953 {
954 BOOL ret;
955 DWORD bufSize = 0;
956 CERT_ALT_NAME_INFO *info;
957 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)12),
958 &bufSize);
959 {
960 (winetest_set_location("encode.c", 1392), 0) ? 0 : winetest_ok(info->cAltEntry == 0, "Expected 0 entries, got %d\n",
961 info->cAltEntry);
962 }
963 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)12), emptyURL,
964 &bufSize);
965 {
966 }
967 }
968 struct encodedBits
969 {
970 const BYTE *encoded;
971 DWORD cbDecoded;
972 };
973 static const struct encodedBits bits[] = {
974 };
975 static void test_encodeBits(DWORD dwEncoding)
976 {
977 DWORD i;
978 {
979 DWORD bufSize = 0;
980 {
981 (winetest_set_location("encode.c", 1802), 0) ? 0 : winetest_ok(bufSize == bits[i].encoded[1] + 2,
982 bits[i].encoded[1] + 2);
983 }
984 }
985 }
986 static void test_decodeBits(DWORD dwEncoding)
987 {
988 DWORD i;
989 {
990 {
991 CRYPT_BIT_BLOB *blob;
992 (winetest_set_location("encode.c", 1835), 0) ? 0 : winetest_ok(blob->cbData == bits[i].cbDecoded,
993 "Unexpected value\n");
994 }
995 }
996 {
997 }
998 }
999 struct Constraints2
1000 {
1001 CERT_BASIC_CONSTRAINTS2_INFO info;
1002 };
1003 static const struct Constraints2 constraints2[] = {
1004 };
1005 static const BYTE encodedDomainName[] = { 0x30, 0x2b, 0x31, 0x29, 0x30, 0x11,
1006 0x16, 0x06, 0x77, 0x69, 0x6e, 0x65, 0x68, 0x71 };
1007 static void test_encodeBasicConstraints(DWORD dwEncoding)
1008 {
1009 CERT_NAME_BLOB nameBlob = { sizeof(encodedDomainName),
1010 (LPBYTE)encodedDomainName };
1011 {
1012 {
1013 }
1014 }
1015 {
1016 }
1017 }
1018 static const unsigned char encodedCommonName[] = {
1019 0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,'J','u','a','n',' ','L','a','n','g',0};
1020 static void test_decodeBasicConstraints(DWORD dwEncoding)
1021 {
1022 static const BYTE inverted[] = { 0x30, 0x06, 0x02, 0x01, 0x01, 0x01, 0x01,
1023 0xff };
1024 DWORD i;
1025 BOOL ret;
1026 BYTE *buf = ((void *)0);
1027 DWORD bufSize = 0;
1028 {
1029 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)15),
1030 0x08000, ((void *)0), (BYTE *)&buf, &bufSize);
1031 {
1032 CERT_BASIC_CONSTRAINTS2_INFO *info =
1033 (winetest_set_location("encode.c", 1984), 0) ? 0 : winetest_ok(!memcmp(info, &constraints2[i].info, sizeof(*info)),
1034 "Unexpected value for item %d\n", i);
1035 }
1036 }
1037 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)15),
1038 (BYTE *)&buf, &bufSize);
1039 {
1040 CERT_BASIC_CONSTRAINTS_INFO *info = (CERT_BASIC_CONSTRAINTS_INFO *)buf;
1041 {
1042 (winetest_set_location("encode.c", 2043), 0) ? 0 : winetest_ok(info->rgSubtreesConstraint[0].cbData ==
1043 info->rgSubtreesConstraint[0].cbData);
1044 (winetest_set_location("encode.c", 2046), 0) ? 0 : winetest_ok(!memcmp(info->rgSubtreesConstraint[0].pbData, encodedDomainName,
1045 sizeof(encodedDomainName)), "Unexpected value\n");
1046 }
1047 }
1048 }
1049 static const BYTE modulus1[] = { 0,0,0,1,1,1,1,1 };
1050 struct EncodedRSAPubKey
1051 {
1052 const BYTE *modulus;
1053 size_t decodedModulusLen;
1054 };
1055 struct EncodedRSAPubKey rsaPubKeys[] = {
1056 };
1057 static void test_encodeRsaPublicKey(DWORD dwEncoding)
1058 {
1059 BYTE toEncode[sizeof(BLOBHEADER) + sizeof(RSAPUBKEY) + sizeof(modulus1)];
1060 RSAPUBKEY *rsaPubKey = (RSAPUBKEY *)(toEncode + sizeof(BLOBHEADER));
1061 BOOL ret;
1062 BYTE *buf = ((void *)0);
1063 DWORD bufSize = 0, i;
1064 ret = CryptDecodeObjectEx(dwEncoding, "1.2.840.113549.1.1.1",
1065 "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
1066 {
1067 {
1068 (winetest_set_location("encode.c", 2210), 0) ? 0 : winetest_ok(bufSize >= sizeof(BLOBHEADER) + sizeof(RSAPUBKEY) +
1069 "Wrong size %d\n", bufSize);
1070 (winetest_set_location("encode.c", 2223), 0) ? 0 : winetest_ok(rsaPubKey->magic == 0x31415352,
1071 rsaPubKey->pubexp);
1072 (winetest_set_location("encode.c", 2229), 0) ? 0 : winetest_ok(!memcmp(buf + sizeof(BLOBHEADER) + sizeof(RSAPUBKEY),
1073 rsaPubKeys[i].modulus, rsaPubKeys[i].decodedModulusLen),
1074 "Unexpected modulus\n");
1075 }
1076 }
1077 }
1078 static const BYTE intSequence[] = { 0x30, 0x1b, 0x02, 0x01, 0x01, 0x02, 0x01,
1079 0x02, 0xff, 0x7f, 0x02, 0x04, 0xba, 0xdd, 0xf0, 0x0d };
1080 static const BYTE mixedSequence[] = { 0x30, 0x27, 0x17, 0x0d, 0x30, 0x35, 0x30,
1081 0xff, 0x7f, 0x02, 0x04, 0xba, 0xdd, 0xf0, 0x0d };
1082 static void test_encodeSequenceOfAny(DWORD dwEncoding)
1083 {
1084 BYTE *buf = ((void *)0);
1085 {
1086 }
1087 {
1088 (winetest_set_location("encode.c", 2284), 0) ? 0 : winetest_ok(!memcmp(buf, mixedSequence, mixedSequence[1] + 2),
1089 "Unexpected value\n");
1090 }
1091 }
1092 static void test_decodeSequenceOfAny(DWORD dwEncoding)
1093 {
1094 BOOL ret;
1095 BYTE *buf = ((void *)0);
1096 DWORD bufSize = 0;
1097 {
1098 {
1099 }
1100 }
1101 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)34), mixedSequence,
1102 &bufSize);
1103 {
1104 CRYPT_SEQUENCE_OF_ANY *seq = (CRYPT_SEQUENCE_OF_ANY *)buf;
1105 (winetest_set_location("encode.c", 2324), 0) ? 0 : winetest_ok(seq->cValue == sizeof(ints) / sizeof(ints[0]),
1106 seq->rgValue[0].cbData);
1107 (winetest_set_location("encode.c", 2330), 0) ? 0 : winetest_ok(!memcmp(seq->rgValue[0].pbData, times[0].encodedTime,
1108 times[0].encodedTime[1] + 2), "Unexpected value\n");
1109 }
1110 }
1111 struct encodedExtensions
1112 {
1113 CERT_EXTENSIONS exts;
1114 };
1115 static BYTE noncrit_ext_data[] = { 0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
1116 static CHAR oid_basic_constraints2[] = "2.5.29.19";
1117 static CERT_EXTENSION nonCriticalExt =
1118 { oid_basic_constraints2, 0, { 8, noncrit_ext_data } };
1119 static const struct encodedExtensions exts[] = {
1120 };
1121 static void test_encodeExtensions(DWORD dwEncoding)
1122 {
1123 DWORD i;
1124 {
1125 {
1126 }
1127 }
1128 {
1129 BOOL ret;
1130 BYTE *buf = ((void *)0);
1131 DWORD bufSize = 0;
1132 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)5),
1133 ((void *)0), (BYTE *)&buf, &bufSize);
1134 {
1135 CERT_EXTENSIONS *ext = (CERT_EXTENSIONS *)buf;
1136 DWORD j;
1137 (winetest_set_location("encode.c", 2405), 0) ? 0 : winetest_ok(ext->cExtension == exts[i].exts.cExtension,
1138 ext->cExtension);
1139 {
1140 (winetest_set_location("encode.c", 2410), 0) ? 0 : winetest_ok(!__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (ext->rgExtension[j].pszObjId) && __builtin_constant_p (exts[i].exts.rgExtension[j].pszObjId) && (__s1_len = strlen (ext->rgExtension[j].pszObjId), __s2_len = strlen (exts[i].exts.rgExtension[j].pszObjId), (!((size_t)(const void *)((ext->rgExtension[j].pszObjId) + 1) - (size_t)(const void *)(ext->rgExtension[j].pszObjId) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((exts[i].exts.rgExtension[j].pszObjId) + 1) - (size_t)(const void *)(exts[i].exts.rgExtension[j].pszObjId) == 1) || __s2_len >= 4)) ? __builtin_strcmp (ext->rgExtension[j].pszObjId, exts[i].exts.rgExtension[j].pszObjId) : (__builtin_constant_p (ext->rgExtension[j].pszObjId) && ((size_t)(const void *)((ext->rgExtension[j].pszObjId) + 1) - (size_t)(const void *)(ext->rgExtension[j].pszObjId) == 1) && (__s1_len = strlen (ext->rgExtension[j].pszObjId), __s1_len < 4) ? (__builtin_constant_p (exts[i].exts.rgExtension[j].pszObjId) && ((size_t)(const void *)((exts[i].exts.rgExtension[j].pszObjId) + 1) - (size_t)(const void *)(exts[i].exts.rgExtension[j].pszObjId) == 1) ? __builtin_strcmp (ext->rgExtension[j].pszObjId, exts[i].exts.rgExtension[j].pszObjId) : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) (exts[i].exts.rgExtension[j].pszObjId); register int __result = (((__const unsigned char *) (__const char *) (ext->rgExtension[j].pszObjId))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (ext->rgExtension[j].pszObjId))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (ext->rgExtension[j].pszObjId))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (ext->rgExtension[j].pszObjId))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (exts[i].exts.rgExtension[j].pszObjId) && ((size_t)(const void *)((exts[i].exts.rgExtension[j].pszObjId) + 1) - (size_t)(const void *)(exts[i].exts.rgExtension[j].pszObjId) == 1) && (__s2_len = strlen (exts[i].exts.rgExtension[j].pszObjId), __s2_len < 4) ? (__builtin_constant_p (ext->rgExtension[j].pszObjId) && ((size_t)(const void *)((ext->rgExtension[j].pszObjId) + 1) - (size_t)(const void *)(ext->rgExtension[j].pszObjId) == 1) ? __builtin_strcmp (ext->rgExtension[j].pszObjId, exts[i].exts.rgExtension[j].pszObjId) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (ext->rgExtension[j].pszObjId); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) (exts[i].exts.rgExtension[j].pszObjId))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) (exts[i].exts.rgExtension[j].pszObjId))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) (exts[i].exts.rgExtension[j].pszObjId))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (exts[i].exts.rgExtension[j].pszObjId))[3]); } } __result; }))) : __builtin_strcmp (ext->rgExtension[j].pszObjId, exts[i].exts.rgExtension[j].pszObjId)))); }),
1141 ext->rgExtension[j].pszObjId);
1142 (winetest_set_location("encode.c", 2415), 0) ? 0 : winetest_ok(!memcmp(ext->rgExtension[j].Value.pbData,
1143 exts[i].exts.rgExtension[j].Value.cbData),
1144 "Unexpected value\n");
1145 }
1146 }
1147 }
1148 }
1149 struct encodedPublicKey
1150 {
1151 const BYTE *encoded;
1152 const BYTE *encodedNoNull;
1153 };
1154 static const BYTE aKey[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd,
1155 0xe, 0xf };
1156 static const BYTE params[] = { 0x02, 0x01, 0x01 };
1157 static const unsigned char bin66[] = {
1158 0x30,0x0f,0x30,0x0a,0x06,0x06,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x05,0x00,0x03,0x01,0x00};
1159 static const unsigned char bin67[] = {
1160 0x30,0x0d,0x30,0x08,0x06,0x06,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x03,0x01,0x00};
1161 static const unsigned char bin69[] = {
1162 0x0f};
1163 static unsigned char bin72[] = { 0x05,0x00};
1164 static CHAR oid_bogus[] = "1.2.3",
1165 oid_rsa[] = "1.2.840.113549";
1166 static const struct encodedPublicKey pubKeys[] = {
1167 { { { oid_rsa, { 0, ((void *)0) } }, { 0, ((void *)0), 0} },
1168 { { oid_rsa, { 2, bin72 } }, { sizeof(aKey), (BYTE *)aKey, 0} } },
1169 { { { oid_rsa, { sizeof(params), (BYTE *)params } }, { sizeof(aKey),
1170 (BYTE *)aKey, 0 } } },
1171 };
1172 static void test_encodePublicKeyInfo(DWORD dwEncoding)
1173 {
1174 DWORD i;
1175 {
1176 BOOL ret;
1177 BYTE *buf = ((void *)0);
1178 DWORD bufSize = 0;
1179 ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)8),
1180 &bufSize);
1181 {
1182 (winetest_set_location("encode.c", 2505), 0) ? 0 : winetest_ok(bufSize == pubKeys[i].encoded[1] + 2 ||
1183 pubKeys[i].encodedNoNull[1] + 2, bufSize);
1184 (winetest_set_location("encode.c", 2510), 0) ? 0 : winetest_ok(!memcmp(buf, pubKeys[i].encoded, pubKeys[i].encoded[1] + 2),
1185 "Unexpected value\n");
1186 (winetest_set_location("encode.c", 2513), 0) ? 0 : winetest_ok(!memcmp(buf, pubKeys[i].encodedNoNull,
1187 pubKeys[i].encodedNoNull[1] + 2), "Unexpected value\n");
1188 }
1189 }
1190 }
1191 static void comparePublicKeyInfo(const CERT_PUBLIC_KEY_INFO *expected,
1192 const CERT_PUBLIC_KEY_INFO *got)
1193 {
1194 (winetest_set_location("encode.c", 2523), 0) ? 0 : winetest_ok(!__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (expected->Algorithm.pszObjId) && __builtin_constant_p (got->Algorithm.pszObjId) && (__s1_len = strlen (expected->Algorithm.pszObjId), __s2_len = strlen (got->Algorithm.pszObjId), (!((size_t)(const void *)((expected->Algorithm.pszObjId) + 1) - (size_t)(const void *)(expected->Algorithm.pszObjId) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((got->Algorithm.pszObjId) + 1) - (size_t)(const void *)(got->Algorithm.pszObjId) == 1) || __s2_len >= 4)) ? __builtin_strcmp (expected->Algorithm.pszObjId, got->Algorithm.pszObjId) : (__builtin_constant_p (expected->Algorithm.pszObjId) && ((size_t)(const void *)((expected->Algorithm.pszObjId) + 1) - (size_t)(const void *)(expected->Algorithm.pszObjId) == 1) && (__s1_len = strlen (expected->Algorithm.pszObjId), __s1_len < 4) ? (__builtin_constant_p (got->Algorithm.pszObjId) && ((size_t)(const void *)((got->Algorithm.pszObjId) + 1) - (size_t)(const void *)(got->Algorithm.pszObjId) == 1) ? __builtin_strcmp (expected->Algorithm.pszObjId, got->Algorithm.pszObjId) : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) (got->Algorithm.pszObjId); register int __result = (((__const unsigned char *) (__const char *) (expected->Algorithm.pszObjId))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (expected->Algorithm.pszObjId))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (expected->Algorithm.pszObjId))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (expected->Algorithm.pszObjId))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (got->Algorithm.pszObjId) && ((size_t)(const void *)((got->Algorithm.pszObjId) + 1) - (size_t)(const void *)(got->Algorithm.pszObjId) == 1) && (__s2_len = strlen (got->Algorithm.pszObjId), __s2_len < 4) ? (__builtin_constant_p (expected->Algorithm.pszObjId) && ((size_t)(const void *)((expected->Algorithm.pszObjId) + 1) - (size_t)(const void *)(expected->Algorithm.pszObjId) == 1) ? __builtin_strcmp (expected->Algorithm.pszObjId, got->Algorithm.pszObjId) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (expected->Algorithm.pszObjId); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) (got->Algorithm.pszObjId))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) (got->Algorithm.pszObjId))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) (got->Algorithm.pszObjId))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (got->Algorithm.pszObjId))[3]); } } __result; }))) : __builtin_strcmp (expected->Algorithm.pszObjId, got->Algorithm.pszObjId)))); }),
1195 expected->PublicKey.cbData, got->PublicKey.cbData);
1196 (winetest_set_location("encode.c", 2538), 0) ? 0 : winetest_ok(!memcmp(expected->PublicKey.pbData, got->PublicKey.pbData,
1197 got->PublicKey.cbData), "Unexpected public key value\n");
1198 }
1199 static void test_decodePublicKeyInfo(DWORD dwEncoding)
1200 {
1201 static const BYTE bogusPubKeyInfo[] = { 0x30, 0x22, 0x30, 0x0d, 0x06, 0x06,
1202 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
1203 BOOL ret;
1204 BYTE *buf = ((void *)0);
1205 DWORD bufSize = 0;
1206 {
1207 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)8),
1208 0x08000, ((void *)0), (BYTE *)&buf, &bufSize);
1209 {
1210 }
1211 }
1212 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)8),
1213 "Expected CRYPT_E_ASN1_CORRUPT, got %08x\n", GetLastError());
1214 }
1215 static const BYTE v1Cert[] = { 0x30, 0x33, 0x02, 0x00, 0x30, 0x02, 0x06, 0x00,
1216 0x02, 0x06, 0x00, 0x03, 0x01, 0x00 };
1217 static const BYTE v2Cert[] = { 0x30, 0x38, 0xa0, 0x03, 0x02, 0x01, 0x01, 0x02,
1218 0x30, 0x5a, 0x30, 0x07, 0x30, 0x02, 0x06, 0x00, 0x03, 0x01, 0x00 };
1219 static const BYTE v3Cert[] = { 0x30, 0x38, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02,
1220 0x30, 0x5a, 0x30, 0x07, 0x30, 0x02, 0x06, 0x00, 0x03, 0x01, 0x00 };
1221 static const BYTE v1CertWithConstraints[] = { 0x30, 0x4b, 0x02, 0x00, 0x30,
1222 0x06, 0x01, 0x01, 0xff, 0x02, 0x01, 0x01 };
1223 static const BYTE v1CertWithSerial[] = { 0x30, 0x4c, 0x02, 0x01, 0x01, 0x30,
1224 0x06, 0x01, 0x01, 0xff, 0x02, 0x01, 0x01 };
1225 static const BYTE bigCert[] = { 0x30, 0x7a, 0x02, 0x01, 0x01, 0x30, 0x02, 0x06,
1226 0x01, 0xff, 0x04, 0x08, 0x30, 0x06, 0x01, 0x01, 0xff, 0x02, 0x01, 0x01 };
1227 static void test_encodeCertToBeSigned(DWORD dwEncoding)
1228 {
1229 BOOL ret;
1230 BYTE *buf = ((void *)0);
1231 DWORD size = 0;
1232 CERT_INFO info = { 0 };
1233 ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)2), ((void *)0),
1234 0x08000, ((void *)0), (BYTE *)&buf, &size);
1235 {
1236 }
1237 {
1238 }
1239 ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)2), &info,
1240 0x08000, ((void *)0), (BYTE *)&buf, &size);
1241 {
1242 }
1243 {
1244 }
1245 }
1246 static void test_decodeCertToBeSigned(DWORD dwEncoding)
1247 {
1248 static const BYTE *corruptCerts[] = { v1Cert, v2Cert, v3Cert,
1249 v1CertWithConstraints, v1CertWithSerial };
1250 BOOL ret;
1251 (winetest_set_location("encode.c", 2727), 0) ? 0 : winetest_ok(!ret && GetLastError() == ((HRESULT)0x80093102L),
1252 "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
1253 {
1254 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)2),
1255 "Expected CRYPT_E_ASN1_CORRUPT, got %08x\n", GetLastError());
1256 }
1257 {
1258 }
1259 }
1260 static const BYTE hash[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd,
1261 0xe, 0xf };
1262 static const BYTE signedBigCert[] = {
1263 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 };
1264 static void test_encodeCert(DWORD dwEncoding)
1265 {
1266 CERT_SIGNED_CONTENT_INFO info = { { sizeof(bigCert), (BYTE *)bigCert },
1267 { ((void *)0), { 0, ((void *)0) } }, { sizeof(hash), (BYTE *)hash, 0 } };
1268 BOOL ret;
1269 BYTE *buf = ((void *)0);
1270 DWORD bufSize = 0;
1271 ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)1), &info,
1272 0x08000, ((void *)0), (BYTE *)&buf, &bufSize);
1273 {
1274 }
1275 }
1276 static void test_decodeCert(DWORD dwEncoding)
1277 {
1278 BOOL ret;
1279 BYTE *buf = ((void *)0);
1280 DWORD size = 0;
1281 {
1282 }
1283 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)2), signedBigCert,
1284 sizeof(signedBigCert), 0x08000, ((void *)0), (BYTE *)&buf, &size);
1285 {
1286 CERT_INFO *info = (CERT_INFO *)buf;
1287 (winetest_set_location("encode.c", 2843), 0) ? 0 : winetest_ok(info->SerialNumber.cbData == 1,
1288 *info->SerialNumber.pbData);
1289 (winetest_set_location("encode.c", 2852), 0) ? 0 : winetest_ok(info->Subject.cbData == sizeof(encodedCommonName),
1290 "Wrong size %d\n", info->Subject.cbData);
1291 (winetest_set_location("encode.c", 2854), 0) ? 0 : winetest_ok(!memcmp(info->Subject.pbData, encodedCommonName,
1292 info->Subject.cbData), "Unexpected subject\n");
1293 }
1294 }
1295 static const BYTE distPointWithUrl[] = { 0x30, 0x19, 0x30, 0x17, 0xa0, 0x15,
1296 0x6e, 0x65, 0x68, 0x71, 0x2e, 0x6f, 0x72, 0x67 };
1297 static const BYTE distPointWithIssuer[] = { 0x30, 0x17, 0x30, 0x15, 0xa2, 0x13,
1298 0x2e, 0x6f, 0x72, 0x67 };
1299 static const BYTE crlReason = 1 |
1300 3;
1301 static void test_encodeCRLDistPoints(DWORD dwEncoding)
1302 {
1303 CRL_DIST_POINTS_INFO xxxinfo = { 0 };
1304 CRL_DIST_POINT point = { { 0 } };
1305 BOOL ret;
1306 BYTE *buf = ((void *)0);
1307 DWORD size = 0;
1308 ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)35), &xxxinfo,
1309 "Expected E_INVALIDARG, got %08x\n", GetLastError());
1310 xxxinfo.cDistPoint = 1;
1311 xxxinfo.rgDistPoint = &point;
1312 ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)35), &xxxinfo,
1313 0x08000, ((void *)0), (BYTE *)&buf, &size);
1314 point.ReasonFlags.cbData = sizeof(crlReason);
1315 {
1316 }
1317 }
1318 static void test_decodeCRLDistPoints(DWORD dwEncoding)
1319 {
1320 BOOL ret;
1321 BYTE *buf = ((void *)0);
1322 DWORD size = 0;
1323 PCERT_ALT_NAME_ENTRY entry;
1324 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)35),
1325 (BYTE *)&buf, &size);
1326 {
1327 (winetest_set_location("encode.c", 3065), 0) ? 0 : winetest_ok(entry->dwAltNameChoice == 7,
1328 "Expected CERT_ALT_NAME_URL, got %d\n", entry->dwAltNameChoice);
1329 }
1330 }
1331 static const BYTE urlIDP[] = { 0x30,0x17,0xa0,0x15,0xa0,0x13,0x86,0x11,0x68,
1332 0x67 };
1333 static void test_encodeCRLIssuingDistPoint(DWORD dwEncoding)
1334 {
1335 BOOL ret;
1336 BYTE *buf = ((void *)0);
1337 DWORD size = 0;
1338 CRL_ISSUING_DIST_POINT point = { { 0 } };
1339 ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)54), ((void *)0),
1340 "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
1341 {
1342 }
1343 ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)54), &point,
1344 0x08000, ((void *)0), (BYTE *)&buf, &size);
1345 {
1346 }
1347 {
1348 }
1349 }
1350 static void compareAltNameEntry(const CERT_ALT_NAME_ENTRY *expected,
1351 const CERT_ALT_NAME_ENTRY *got)
1352 {
1353 (winetest_set_location("encode.c", 3149), 0) ? 0 : winetest_ok(expected->dwAltNameChoice == got->dwAltNameChoice,
1354 got->dwAltNameChoice);
1355 {
1356 {
1357 (winetest_set_location("encode.c", 3161), 0) ? 0 : winetest_ok((!(*expected).pwszURL && !(*got).pwszURL) ||
1358 !lstrcmpW((*expected).pwszURL, (*got).pwszURL), "Unexpected name\n");
1359 }
1360 }
1361 }
1362 static void compareAltNameInfo(const CERT_ALT_NAME_INFO *expected,
1363 const CERT_ALT_NAME_INFO *got)
1364 {
1365 }
1366 static const BYTE v1CRL[] = { 0x30, 0x15, 0x30, 0x02, 0x06, 0x00, 0x18, 0x0f,
1367 0x30, 0x5a };
1368 static const BYTE v2CRL[] = { 0x30, 0x18, 0x02, 0x01, 0x01, 0x30, 0x02, 0x06,
1369 0x30, 0x30, 0x30, 0x30, 0x5a };
1370 static const BYTE v1CRLWithIssuer[] = { 0x30, 0x2c, 0x30, 0x02, 0x06, 0x00,
1371 0x5a };
1372 static const BYTE v1CRLWithIssuerAndEmptyEntry[] = { 0x30, 0x43, 0x30, 0x02,
1373 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a };
1374 static const BYTE v1CRLWithIssuerAndEntry[] = { 0x30, 0x44, 0x30, 0x02, 0x06,
1375 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a };
1376 static const BYTE v1CRLWithEntryExt[] = { 0x30,0x5a,0x30,0x02,0x06,0x00,0x30,
1377 0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
1378 static const BYTE v1CRLWithExt[] = { 0x30,0x5c,0x30,0x02,0x06,0x00,0x30,0x15,
1379 0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
1380 static const BYTE v2CRLWithExt[] = { 0x30,0x5c,0x02,0x01,0x01,0x30,0x02,0x06,
1381 0x13,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
1382 static const BYTE v2CRLWithIssuingDistPoint[] = { 0x30,0x5c,0x02,0x01,0x01,
1383 0x03,0x55,0x1d,0x13,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
1384 static void test_encodeCRLToBeSigned(DWORD dwEncoding)
1385 {
1386 BOOL ret;
1387 BYTE *buf = ((void *)0);
1388 DWORD size = 0;
1389 CRL_INFO info = { 0 };
1390 {
1391 (winetest_set_location("encode.c", 3386), 0) ? 0 : winetest_ok(size == sizeof(v1CRLWithIssuerAndEntry),
1392 "Wrong size %d\n", size);
1393 }
1394 {
1395 }
1396 ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)3), &info,
1397 0x08000, ((void *)0), (BYTE *)&buf, &size);
1398 {
1399 }
1400 {
1401 }
1402 }
1403 static const BYTE verisignCRL[] = { 0x30, 0x82, 0x01, 0xb1, 0x30, 0x82, 0x01,
1404 0x61,0xc0,0x99,0x16,0x71,0x05,0xb6,0x25,0x14,0x64,0x4f,0x30 };
1405 static void test_decodeCRLToBeSigned(DWORD dwEncoding)
1406 {
1407 BOOL ret;
1408 BYTE *buf = ((void *)0);
1409 DWORD size = 0, i;
1410 {
1411 }
1412 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)3),
1413 (BYTE *)&buf, &size);
1414 {
1415 CRL_INFO *info = (CRL_INFO *)buf;
1416 (winetest_set_location("encode.c", 4016), 0) ? 0 : winetest_ok(info->cCRLEntry == 0, "Expected 0 CRL entries, got %d\n",
1417 "Unexpected issuer\n");
1418 }
1419 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)3),
1420 0x08000, ((void *)0), (BYTE *)&buf, &size);
1421 {
1422 CRL_INFO *info = (CRL_INFO *)buf;
1423 (winetest_set_location("encode.c", 4041), 0) ? 0 : winetest_ok(info->cCRLEntry == 1, "Expected 1 CRL entries, got %d\n",
1424 "Unexpected issuer\n");
1425 }
1426 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)3),
1427 0x08000, ((void *)0), (BYTE *)&buf, &size);
1428 {
1429 CRL_INFO *info = (CRL_INFO *)buf;
1430 (winetest_set_location("encode.c", 4085), 0) ? 0 : winetest_ok(info->cCRLEntry == 209, "Expected 209 CRL entries, got %d\n",
1431 info->cExtension);
1432 }
1433 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)3),
1434 ((void *)0), (BYTE *)&buf, &size);
1435 {
1436 }
1437 }
1438 static const BYTE authorityKeyIdWithIssuer[] = { 0x30,0x19,0xa1,0x17,0x30,0x15,
1439 0x20,0x4c,0x61,0x6e,0x67,0x00 };
1440 static const BYTE authorityKeyIdWithSerial[] = { 0x30,0x03,0x82,0x01,0x01 };
1441 static void test_encodeAuthorityKeyId(DWORD dwEncoding)
1442 {
1443 CERT_AUTHORITY_KEY_ID_INFO info = { { 0 } };
1444 BOOL ret;
1445 BYTE *buf = ((void *)0);
1446 DWORD size = 0;
1447 {
1448 }
1449 {
1450 }
1451 ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)9), &info,
1452 0x08000, ((void *)0), (BYTE *)&buf, &size);
1453 {
1454 }
1455 ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)9), &info,
1456 0x08000, ((void *)0), (BYTE *)&buf, &size);
1457 {
1458 (winetest_set_location("encode.c", 4284), 0) ? 0 : winetest_ok(size == sizeof(authorityKeyIdWithSerial), "Unexpected size %d\n",
1459 size);
1460 }
1461 }
1462 static void test_decodeAuthorityKeyId(DWORD dwEncoding)
1463 {
1464 BOOL ret;
1465 LPBYTE buf = ((void *)0);
1466 DWORD size = 0;
1467 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)9),
1468 (BYTE *)&buf, &size);
1469 {
1470 }
1471 ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)9),
1472 0x08000, ((void *)0), (BYTE *)&buf, &size);
1473 {
1474 (winetest_set_location("encode.c", 4355), 0) ? 0 : winetest_ok(size >= sizeof(CERT_AUTHORITY_KEY_ID_INFO), "Unexpected size %d\n",
1475 "Unexpected serial number\n");
1476 }
1477 }
1478 static void testExportPublicKey(HCRYPTPROV csp, PCERT_PUBLIC_KEY_INFO *pInfo)
1479 {
1480 BOOL ret;
1481 DWORD size = 0;
1482 {
1483 ret = CryptExportPublicKeyInfoEx(csp, 2, 0x00000001,
1484 ((void *)0), 0, ((void *)0), ((void *)0), &size);
1485 {
1486 {
1487 (winetest_set_location("encode.c", 4416), 0) ? 0 : winetest_ok(!__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p ((*pInfo)->Algorithm.pszObjId) && __builtin_constant_p ("1.2.840.113549.1.1.1") && (__s1_len = strlen ((*pInfo)->Algorithm.pszObjId), __s2_len = strlen ("1.2.840.113549.1.1.1"), (!((size_t)(const void *)(((*pInfo)->Algorithm.pszObjId) + 1) - (size_t)(const void *)((*pInfo)->Algorithm.pszObjId) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("1.2.840.113549.1.1.1") + 1) - (size_t)(const void *)("1.2.840.113549.1.1.1") == 1) || __s2_len >= 4)) ? __builtin_strcmp ((*pInfo)->Algorithm.pszObjId, "1.2.840.113549.1.1.1") : (__builtin_constant_p ((*pInfo)->Algorithm.pszObjId) && ((size_t)(const void *)(((*pInfo)->Algorithm.pszObjId) + 1) - (size_t)(const void *)((*pInfo)->Algorithm.pszObjId) == 1) && (__s1_len = strlen ((*pInfo)->Algorithm.pszObjId), __s1_len < 4) ? (__builtin_constant_p ("1.2.840.113549.1.1.1") && ((size_t)(const void *)(("1.2.840.113549.1.1.1") + 1) - (size_t)(const void *)("1.2.840.113549.1.1.1") == 1) ? __builtin_strcmp ((*pInfo)->Algorithm.pszObjId, "1.2.840.113549.1.1.1") : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"); register int __result = (((__const unsigned char *) (__const char *) ((*pInfo)->Algorithm.pszObjId))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) ((*pInfo)->Algorithm.pszObjId))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) ((*pInfo)->Algorithm.pszObjId))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) ((*pInfo)->Algorithm.pszObjId))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("1.2.840.113549.1.1.1") && ((size_t)(const void *)(("1.2.840.113549.1.1.1") + 1) - (size_t)(const void *)("1.2.840.113549.1.1.1") == 1) && (__s2_len = strlen ("1.2.840.113549.1.1.1"), __s2_len < 4) ? (__builtin_constant_p ((*pInfo)->Algorithm.pszObjId) && ((size_t)(const void *)(((*pInfo)->Algorithm.pszObjId) + 1) - (size_t)(const void *)((*pInfo)->Algorithm.pszObjId) == 1) ? __builtin_strcmp ((*pInfo)->Algorithm.pszObjId, "1.2.840.113549.1.1.1") : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) ((*pInfo)->Algorithm.pszObjId); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[3]); } } __result; }))) : __builtin_strcmp ((*pInfo)->Algorithm.pszObjId, "1.2.840.113549.1.1.1")))); }),
1488 (*pInfo)->Algorithm.pszObjId);
1489 }
1490 }
1491 }
1492 }
1493 static const BYTE expiredCert[] = { 0x30, 0x82, 0x01, 0x33, 0x30, 0x81, 0xe2,
1494 0x49, 0xe5, 0xf9, 0x65, 0xf3 };
1495 static void testImportPublicKey(HCRYPTPROV csp, PCERT_PUBLIC_KEY_INFO info)
1496 {
1497 BOOL ret;
1498 HCRYPTKEY key;
1499 PCCERT_CONTEXT context;
1500 (winetest_set_location("encode.c", 4464), 0) ? 0 : winetest_ok(!ret && GetLastError() == 2,
1501 GetLastError());
1502 {
1503 (winetest_set_location("encode.c", 4485), 0) ? 0 : winetest_ok(!__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p ("1.2.840.113549.1.1.1") && __builtin_constant_p (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) && (__s1_len = strlen ("1.2.840.113549.1.1.1"), __s2_len = strlen (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId), (!((size_t)(const void *)(("1.2.840.113549.1.1.1") + 1) - (size_t)(const void *)("1.2.840.113549.1.1.1") == 1) || __s1_len >= 4) && (!((size_t)(const void *)((context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) + 1) - (size_t)(const void *)(context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) == 1) || __s2_len >= 4)) ? __builtin_strcmp ("1.2.840.113549.1.1.1", context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) : (__builtin_constant_p ("1.2.840.113549.1.1.1") && ((size_t)(const void *)(("1.2.840.113549.1.1.1") + 1) - (size_t)(const void *)("1.2.840.113549.1.1.1") == 1) && (__s1_len = strlen ("1.2.840.113549.1.1.1"), __s1_len < 4) ? (__builtin_constant_p (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) && ((size_t)(const void *)((context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) + 1) - (size_t)(const void *)(context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) == 1) ? __builtin_strcmp ("1.2.840.113549.1.1.1", context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId); register int __result = (((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) && ((size_t)(const void *)((context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) + 1) - (size_t)(const void *)(context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) == 1) && (__s2_len = strlen (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId), __s2_len < 4) ? (__builtin_constant_p ("1.2.840.113549.1.1.1") && ((size_t)(const void *)(("1.2.840.113549.1.1.1") + 1) - (size_t)(const void *)("1.2.840.113549.1.1.1") == 1) ? __builtin_strcmp ("1.2.840.113549.1.1.1", context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId))[3]); } } __result; }))) : __builtin_strcmp ("1.2.840.113549.1.1.1", context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId)))); }),
1504 &context->pCertInfo->SubjectPublicKeyInfo, 0, 0, ((void *)0), &key);
1505 }
1506 }
1507 static const char cspName[] = "WineCryptTemp";
1508 static void testPortPublicKeyInfo(void)
1509 {
1510 HCRYPTPROV csp;
1511 BOOL ret;
1512 CryptAcquireContextA(&csp, cspName, "Microsoft Base Cryptographic Provider v1.0", 1,
1513 0x00000008);
1514 ret = CryptAcquireContextA(&csp, cspName, "Microsoft Base Cryptographic Provider v1.0", 1,
1515 0x00000010);
1516 }
1517 void func_encode(void)
1518 {
1519 test_encodeCRLDistPoints(0x00000001);
1520 }
1521
1522 /* { dg-final { scan-tree-dump-times " xxxinfo = {}" 1 "dse1"} } */