VirtualBox

source: vbox/trunk/include/iprt/asn1.h@ 85202

Last change on this file since 85202 was 85121, checked in by vboxsync, 4 years ago

iprt/cdefs.h: Refactored the typedef use of DECLCALLBACK as well as DECLCALLBACKMEMBER to wrap the whole expression, similar to the DECLR?CALLBACKMEMBER macros. This allows adding a throw() at the end when compiling with the VC++ compiler to indicate that the callbacks won't throw anything, so we can stop supressing the C5039 warning about passing functions that can potential throw C++ exceptions to extern C code that can't necessarily cope with such (unwind,++). Introduced a few _EX variations that allows specifying different/no calling convention too, as that's handy when dynamically resolving host APIs. Fixed numerous places missing DECLCALLBACK and such. Left two angry @todos regarding use of CreateThread. bugref:9794

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 97.4 KB
Line 
1/** @file
2 * IPRT - Abstract Syntax Notation One (ASN.1).
3 */
4
5/*
6 * Copyright (C) 2006-2020 Oracle Corporation
7 *
8 * This file is part of VirtualBox Open Source Edition (OSE), as
9 * available from http://www.virtualbox.org. This file is free software;
10 * you can redistribute it and/or modify it under the terms of the GNU
11 * General Public License (GPL) as published by the Free Software
12 * Foundation, in version 2 as it comes in the "COPYING" file of the
13 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15 *
16 * The contents of this file may alternatively be used under the terms
17 * of the Common Development and Distribution License Version 1.0
18 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
19 * VirtualBox OSE distribution, in which case the provisions of the
20 * CDDL are applicable instead of those of the GPL.
21 *
22 * You may elect to license modified versions of this file under the
23 * terms and conditions of either the GPL or the CDDL or both.
24 */
25
26#ifndef IPRT_INCLUDED_asn1_h
27#define IPRT_INCLUDED_asn1_h
28#ifndef RT_WITHOUT_PRAGMA_ONCE
29# pragma once
30#endif
31
32#include <iprt/time.h>
33#include <iprt/stdarg.h>
34#include <iprt/errcore.h>
35#include <iprt/formats/asn1.h>
36
37
38RT_C_DECLS_BEGIN
39
40/** @defgroup grp_rt_asn1 RTAsn1 - Abstract Syntax Notation One
41 * @ingroup grp_rt
42 * @{
43 */
44
45
46/** Pointer to ASN.1 allocation information. */
47typedef struct RTASN1ALLOCATION *PRTASN1ALLOCATION;
48/** Pointer to ASN.1 array allocation information. */
49typedef struct RTASN1ARRAYALLOCATION *PRTASN1ARRAYALLOCATION;
50/** Pointer to a ASN.1 byte decoder cursor. */
51typedef struct RTASN1CURSOR *PRTASN1CURSOR;
52
53
54/**
55 * Sketch of a custom ASN.1 allocator virtual method table.
56 *
57 * Any information required by the allocator should be associated with this
58 * structure, i.e. use this as a kind of parent class. This saves storage in
59 * RTASN1ALLOCATORINFO and possibly reduces the number of parameters by one.
60 */
61typedef struct RTASN1ALLOCATORVTABLE
62{
63 /**
64 * Free a chunk of memory allocated by this allocator.
65 *
66 * @returns IPRT status code.
67 * @param pThis Pointer to the vtable structure.
68 * @param pAllocation Pointer to the allocation info structure.
69 * @param pv Pointer to the memory that shall be freed. Not NULL.
70 */
71 DECLCALLBACKMEMBER(void, pfnFree,(struct RTASN1ALLOCATORVTABLE const *pThis, PRTASN1ALLOCATION pAllocation,
72 void *pv));
73 /**
74 * Allocates a chunk of memory, all initialized to zero.
75 *
76 * @returns IPRT status code.
77 * @param pThis Pointer to the vtable structure.
78 * @param pAllocation Pointer to the allocation info structure.
79 * @param ppv Where to store the pointer on success.
80 * @param cb The minimum number of bytes to allocate. The actual
81 * number of bytes allocated shall be stored in
82 * pInfo->cbAllocated on success.
83 */
84 DECLCALLBACKMEMBER(int, pfnAlloc,(struct RTASN1ALLOCATORVTABLE const *pThis, PRTASN1ALLOCATION pAllocation,
85 void **ppv, size_t cb));
86 /**
87 * Reallocates a memory allocation.
88 *
89 * New memory does not need to be initialized, the caller takes care of that.
90 *
91 * This will not need to deal with free (@a cbNew == 0) or the initial
92 * allocation (@a pvOld == NULL), those calls will be directed to pfnFree and
93 * pfnAlloc respectively.
94 *
95 * @returns IPRT status code.
96 * @param pThis Pointer to the vtable structure.
97 * @param pAllocation Pointer to the allocation info structure.
98 * @param pvOld Pointer to the current allocation. Shall remain
99 * valid on failure, but may be invalid on success.
100 * @param ppvNew Where to store the pointer on success. Shall not be
101 * touched, except on successful returns.
102 * @param cbNew The new minimum allocation size. The actual number
103 * of bytes allocated shall be stored in
104 * pInfo->cbAllocated on success.
105 */
106 DECLCALLBACKMEMBER(int, pfnRealloc,(struct RTASN1ALLOCATORVTABLE const *pThis, PRTASN1ALLOCATION pAllocation,
107 void *pvOld, void **ppvNew, size_t cbNew));
108
109 /**
110 * Frees an array allocation (the array an all instances in it).
111 *
112 * @returns IPRT status code.
113 * @param pThis Pointer to the vtable structure.
114 * @param pAllocation Pointer to the allocation info structure.
115 * @param papvArray Pointer to the pointer array to be freed. Not NULL.
116 */
117 DECLCALLBACKMEMBER(void, pfnFreeArray,(struct RTASN1ALLOCATORVTABLE const *pThis, PRTASN1ARRAYALLOCATION pAllocation,
118 void **papvArray));
119 /**
120 * Grows the array to at least @a cMinEntries.
121 *
122 * The entries are initalized with ZEROs.
123 *
124 * @returns IPRT status code.
125 * @param pThis Pointer to the vtable structure.
126 * @param pAllocation Pointer to the allocation info structure.
127 * @param ppapvArray Pointer to the pointer to the array to be grown (or
128 * allocated).
129 * @param cMinEntries The minimum number of entries (array size and
130 * instantiated entries) that must be available
131 * on successful return.
132 */
133 DECLCALLBACKMEMBER(int, pfnGrowArray,(struct RTASN1ALLOCATORVTABLE const *pThis, PRTASN1ARRAYALLOCATION pAllocation,
134 void ***ppapvArray, uint32_t cMinEntries));
135 /**
136 * Shrinks the array (depends on allocator policy).
137 *
138 * If memory isn't freed, the implementation must fill the entries being
139 * shredded with ZEROs so the growth optimizations in RTAsn1MemResizeArray
140 * returns ZEROed entries.
141 *
142 * @returns IPRT status code.
143 * @param pThis Pointer to the vtable structure.
144 * @param pAllocation Pointer to the allocation info structure.
145 * @param ppapvArray Pointer to the pointer to the array to shrunk.
146 * @param cNew The new entry count.
147 * @param cCurrent The new entry count.
148 */
149 DECLCALLBACKMEMBER(void, pfnShrinkArray,(struct RTASN1ALLOCATORVTABLE const *pThis, PRTASN1ARRAYALLOCATION pAllocation,
150 void ***ppapvArray, uint32_t cNew, uint32_t cCurrent));
151} RTASN1ALLOCATORVTABLE;
152/** Pointer to an ASN.1 allocator vtable. */
153typedef RTASN1ALLOCATORVTABLE *PRTASN1ALLOCATORVTABLE;
154/** Pointer to a const ASN.1 allocator vtable. */
155typedef RTASN1ALLOCATORVTABLE const *PCRTASN1ALLOCATORVTABLE;
156
157/** The default ASN.1 allocator. */
158extern RTDATADECL(RTASN1ALLOCATORVTABLE const) g_RTAsn1DefaultAllocator;
159
160/** The Electric Fence ASN.1 allocator. */
161extern RTDATADECL(RTASN1ALLOCATORVTABLE const) g_RTAsn1EFenceAllocator;
162
163/** The safer ASN.1 allocator for sensitive data. */
164extern RTDATADECL(RTASN1ALLOCATORVTABLE const) g_RTAsn1SaferAllocator;
165
166
167/**
168 * Allocation information.
169 */
170typedef struct RTASN1ALLOCATION
171{
172 /** The number of bytes currently allocated. */
173 uint32_t cbAllocated;
174 /** Number of realloc calls. */
175 uint16_t cReallocs;
176 /** Reserved / padding. */
177 uint16_t uReserved0;
178 /** Allocator vtable, NULL for the default allocator. */
179 PCRTASN1ALLOCATORVTABLE pAllocator;
180} RTASN1ALLOCATION;
181
182
183/**
184 * Pointer array allocation information.
185 *
186 * Used by SET OF and SEQUENCE OF structures (typically automatically
187 * generated).
188 */
189typedef struct RTASN1ARRAYALLOCATION
190{
191 /** The size of the array entry. */
192 uint32_t cbEntry;
193 /** The size of the pointer array allocation. */
194 uint32_t cPointersAllocated;
195 /** Number of entry instances allocated. This can be greater than the
196 * official array size. */
197 uint32_t cEntriesAllocated;
198 /** Number of array resizing calls (for increasing growth rate).
199 * Maintained by RTAsn1MemResizeArray(). */
200 uint16_t cResizeCalls;
201 /** Reserved / padding. */
202 uint16_t uReserved0;
203 /** Allocator vtable, NULL for the default allocator. */
204 PCRTASN1ALLOCATORVTABLE pAllocator;
205} RTASN1ARRAYALLOCATION;
206
207
208/**
209 * Allocate a block of zero initialized memory.
210 *
211 * @returns IPRT status code.
212 * @param pAllocation The allocation record (initialized by
213 * RTAsn1CursorInitAllocation or similar).
214 * @param ppvMem Where to return the pointer to the block.
215 * @param cbMem The minimum number of bytes to allocate.
216 */
217RTDECL(int) RTAsn1MemAllocZ(PRTASN1ALLOCATION pAllocation, void **ppvMem, size_t cbMem);
218
219/**
220 * Allocates a block of memory initialized to the content of @a pvSrc.
221 *
222 * @returns IPRT status code.
223 * @param pAllocation The allocation record (initialized by
224 * RTAsn1CursorInitAllocation or similar).
225 * @param ppvMem Where to return the pointer to the block.
226 * @param pvSrc The source memory.
227 * @param cbMem The minimum number of bytes to allocate.
228 */
229RTDECL(int) RTAsn1MemDup(PRTASN1ALLOCATION pAllocation, void **ppvMem, void const *pvSrc, size_t cbMem);
230
231/**
232 * Free a memory block.
233 *
234 * @param pAllocation The allocation record (initialized by
235 * RTAsn1CursorInitAllocation or similar).
236 * @param pv The memory block to free. NULL will be ignored.
237 */
238RTDECL(void) RTAsn1MemFree(PRTASN1ALLOCATION pAllocation, void *pv);
239
240/**
241 * Initalize an allocation.
242 *
243 * @returns pAllocation
244 * @param pAllocation The allocation record (initialized by
245 * RTAsn1CursorInitAllocation or similar).
246 * @param pAllocator The allocator
247 */
248RTDECL(PRTASN1ALLOCATION) RTAsn1MemInitAllocation(PRTASN1ALLOCATION pAllocation, PCRTASN1ALLOCATORVTABLE pAllocator);
249
250/**
251 * Initalize an array allocation.
252 *
253 * @returns pAllocation
254 * @param pAllocation The allocation record (initialized by
255 * RTAsn1CursorInitAllocation or similar).
256 * @param pAllocator The allocator
257 * @param cbEntry The entry size.
258 */
259RTDECL(PRTASN1ARRAYALLOCATION) RTAsn1MemInitArrayAllocation(PRTASN1ARRAYALLOCATION pAllocation,
260 PCRTASN1ALLOCATORVTABLE pAllocator, size_t cbEntry);
261
262/**
263 * Resize an array with zero initialized memory.
264 *
265 * @returns IPRT status code.
266 * @param pAllocation The allocation record (initialized by
267 * RTAsn1CursorInitAllocation or similar).
268 * @param ppapvArray Pointer to the variable pointing to the array. This is
269 * both input and output. Remains valid on failure.
270 * @param cCurrent The current entry count. (Relevant for zero
271 * initialization of the new entries.)
272 * @param cNew The new entry count.
273 */
274RTDECL(int) RTAsn1MemResizeArray(PRTASN1ARRAYALLOCATION pAllocation, void ***ppapvArray, uint32_t cCurrent, uint32_t cNew);
275
276/**
277 * Frees an array and all its entries.
278 *
279 * @param pAllocation The array allocation record (initialized by
280 * RTAsn1CursorInitArrayAllocation or similar).
281 * @param papvArray The array to free. NULL is ignored.
282 */
283RTDECL(void) RTAsn1MemFreeArray(PRTASN1ARRAYALLOCATION pAllocation, void **papvArray);
284
285
286/** Pointer to a core ASN.1 encoding info structure. */
287typedef struct RTASN1CORE *PRTASN1CORE;
288/** Pointer to a const core ASN.1 encoding info structure. */
289typedef struct RTASN1CORE const *PCRTASN1CORE;
290
291RTDECL(int) RTAsn1ContentAllocZ(struct RTASN1CORE *pAsn1Core, size_t cb, PCRTASN1ALLOCATORVTABLE pAllocator);
292RTDECL(int) RTAsn1ContentDup(struct RTASN1CORE *pAsn1Core, void const *pvSrc, size_t cbSrc, PCRTASN1ALLOCATORVTABLE pAllocator);
293RTDECL(int) RTAsn1ContentReallocZ(struct RTASN1CORE *pAsn1Core, size_t cb, PCRTASN1ALLOCATORVTABLE pAllocator);
294RTDECL(void) RTAsn1ContentFree(struct RTASN1CORE *pAsn1Core);
295
296
297
298/**
299 * ASN.1 object enumeration callback.
300 *
301 * @returns IPRT status code. VINF_SUCCESS continues the enumberation, all
302 * others quit it and is returned to the caller's caller.
303 * @param pAsn1Core The ASN.1 object we're called back about.
304 * @param pszName The member name. Array member names ends with
305 * '[#]'.
306 * @param uDepth The current depth.
307 * @param pvUser Callback user parameter.
308 */
309typedef DECLCALLBACKTYPE(int, FNRTASN1ENUMCALLBACK,(struct RTASN1CORE *pAsn1Core, const char *pszName, uint32_t uDepth,
310 void *pvUser));
311/** Pointer to an ASN.1 object enumeration callback. */
312typedef FNRTASN1ENUMCALLBACK *PFNRTASN1ENUMCALLBACK;
313
314/**
315 * ASN.1 object encoding writer callback.
316 *
317 * @returns IPRT status code.
318 * @param pbBuf Pointer to the bytes to output.
319 * @param cbToWrite The number of bytes to write.
320 * @param pvUser Callback user parameter.
321 * @param pErrInfo Where to store extended error info. Optional.
322 */
323typedef DECLCALLBACKTYPE(int, FNRTASN1ENCODEWRITER,(const void *pvBuf, size_t cbToWrite, void *pvUser, PRTERRINFO pErrInfo));
324/** Pointer to an ASN.1 encoding writer callback. */
325typedef FNRTASN1ENCODEWRITER *PFNRTASN1ENCODEWRITER;
326
327/** @name ASN.1 Vtable Method Types
328 * @{ */
329
330/**
331 * Destructor.
332 *
333 * RTAsn1Destroy will first destroy all children by recursive calls to pfnEnum,
334 * afterwards it will call this method to release any memory or other resources
335 * associated with this object. The memory backing the object structure shall
336 * not be freed by this method.
337 *
338 * @param pThisCore Pointer to the ASN.1 core to destroy.
339 */
340typedef DECLCALLBACKTYPE(void, FNRTASN1COREVTDTOR,(PRTASN1CORE pThisCore));
341/** Pointer to a FNRTASN1COREVTDTOR method. */
342typedef FNRTASN1COREVTDTOR *PFNRTASN1COREVTDTOR;
343
344/**
345 * Enumerate members (not necessary for primitive objects).
346 *
347 * @returns IPRT status code, any non VINF_SUCCESS value stems from pfnCallback.
348 * @param pThisCore Pointer to the ASN.1 core to enumerate members of.
349 * @param pfnCallback The callback.
350 * @param uDepth The depth of this object. Children are at +1.
351 * @param pvUser Callback user argument.
352 */
353typedef DECLCALLBACKTYPE(int, FNRTASN1COREVTENUM,(PRTASN1CORE pThisCore, PFNRTASN1ENUMCALLBACK pfnCallback,
354 uint32_t uDepth, void *pvUser));
355/** Pointer to a FNRTASN1COREVTENUM method. */
356typedef FNRTASN1COREVTENUM *PFNRTASN1COREVTENUM;
357
358/**
359 * Clone method.
360 *
361 * @param pThisCore Pointer to the ASN.1 core to initialize as a clone
362 * of pSrcClone. (The caller is responsible for making
363 * sure there is sufficent space and such.)
364 * @param pSrcCore The object to clone.
365 * @param pAllocator The allocator to use.
366 */
367typedef DECLCALLBACKTYPE(int, FNRTASN1COREVTCLONE,(PRTASN1CORE pThisCore, PCRTASN1CORE pSrcCore,
368 PCRTASN1ALLOCATORVTABLE pAllocator));
369/** Pointer to a FNRTASN1COREVTCLONE method. */
370typedef FNRTASN1COREVTCLONE *PFNRTASN1COREVTCLONE;
371
372/**
373 * Compare method.
374 *
375 * The caller makes sure both cores are present and have the same Vtable.
376 *
377 * @returns 0 if equal, -1 if @a pLeft is smaller, 1 if @a pLeft is larger.
378 * @param pLeftCore Pointer to the ASN.1 core of the left side object.
379 * @param pRightCore Pointer to the ASN.1 core of the right side object.
380 */
381typedef DECLCALLBACKTYPE(int, FNRTASN1COREVTCOMPARE,(PCRTASN1CORE pLeftCore, PCRTASN1CORE pRightCore));
382/** Pointer to a FNRTASN1COREVTCOMPARE method. */
383typedef FNRTASN1COREVTCOMPARE *PFNRTASN1COREVTCOMPARE;
384
385/**
386 * Check sanity method.
387 *
388 * @returns IPRT status code.
389 * @param pThisCore Pointer to the ASN.1 core of the object to check out.
390 * @param fFlags See RTASN1_CHECK_SANITY_F_XXX.
391 * @param pErrInfo Where to return additional error details. Optional.
392 * @param pszErrorTag Tag for the additional error details.
393 */
394typedef DECLCALLBACKTYPE(int, FNRTASN1COREVTCHECKSANITY,(PCRTASN1CORE pThisCore, uint32_t fFlags,
395 PRTERRINFO pErrInfo, const char *pszErrorTag));
396/** Pointer to a FNRTASN1COREVTCHECKSANITY method. */
397typedef FNRTASN1COREVTCHECKSANITY *PFNRTASN1COREVTCHECKSANITY;
398
399/**
400 * Optional encoding preparations.
401 *
402 * On successful return, the pThisCore->cb value shall be valid and up to date.
403 * Will be called for any present object, including ones with default values and
404 * similar.
405 *
406 * @returns IPRT status code
407 * @param pThisCore Pointer to the ASN.1 core to enumerate members of.
408 * @param fFlags Encoding flags, RTASN1ENCODE_F_XXX.
409 * @param pErrInfo Where to return extra error information. Optional.
410 */
411typedef DECLCALLBACKTYPE(int, FNRTASN1COREVTENCODEPREP,(PRTASN1CORE pThisCore, uint32_t fFlags, PRTERRINFO pErrInfo));
412/** Pointer to a FNRTASN1COREVTENCODEWRITE method. */
413typedef FNRTASN1COREVTENCODEPREP *PFNRTASN1COREVTENCODEPREP;
414
415/**
416 * Optional encoder writer.
417 *
418 * This writes the header as well as all the content. Will be called for any
419 * present object, including ones with default values and similar.
420 *
421 * @returns IPRT status code.
422 * @param pThisCore Pointer to the ASN.1 core to enumerate members of.
423 * @param fFlags Encoding flags, RTASN1ENCODE_F_XXX.
424 * @param pfnWriter The output writer function.
425 * @param pvUser The user context for the writer function.
426 * @param pErrInfo Where to return extra error information. Optional.
427 */
428typedef DECLCALLBACKTYPE(int, FNRTASN1COREVTENCODEWRITE,(PRTASN1CORE pThisCore, uint32_t fFlags, PFNRTASN1ENCODEWRITER pfnWriter,
429 void *pvUser, PRTERRINFO pErrInfo));
430/** Pointer to a FNRTASN1COREVTENCODEWRITE method. */
431typedef FNRTASN1COREVTENCODEWRITE *PFNRTASN1COREVTENCODEWRITE;
432/** @} */
433
434/** Mask of common flags. These will be propagated during sanity checking.
435 * Bits not in this mask are type specfic. */
436#define RTASN1_CHECK_SANITY_F_COMMON_MASK UINT32_C(0xffff0000)
437
438/**
439 * ASN.1 core vtable.
440 */
441typedef struct RTASN1COREVTABLE
442{
443 /** The name. */
444 const char *pszName;
445 /** Size of the structure. */
446 uint32_t cbStruct;
447 /** The default tag, UINT8_MAX if not applicable. */
448 uint8_t uDefaultTag;
449 /** The default class and flags. */
450 uint8_t fDefaultClass;
451 /** Reserved for later / alignment. */
452 uint16_t uReserved;
453 /** @copydoc FNRTASN1COREVTDTOR */
454 PFNRTASN1COREVTDTOR pfnDtor;
455 /** @copydoc FNRTASN1COREVTENUM */
456 PFNRTASN1COREVTENUM pfnEnum;
457 /** @copydoc FNRTASN1COREVTCLONE */
458 PFNRTASN1COREVTCLONE pfnClone;
459 /** @copydoc FNRTASN1COREVTCOMPARE */
460 PFNRTASN1COREVTCOMPARE pfnCompare;
461 /** @copydoc FNRTASN1COREVTCHECKSANITY */
462 PFNRTASN1COREVTCHECKSANITY pfnCheckSanity;
463 /** @copydoc FNRTASN1COREVTENCODEPREP */
464 PFNRTASN1COREVTENCODEPREP pfnEncodePrep;
465 /** @copydoc FNRTASN1COREVTENUM */
466 PFNRTASN1COREVTENCODEWRITE pfnEncodeWrite;
467} RTASN1COREVTABLE;
468/** Pointer to an ASN.1 allocator vtable. */
469typedef struct RTASN1COREVTABLE *PRTASN1COREVTABLE;
470/** Pointer to a const ASN.1 allocator vtable. */
471typedef RTASN1COREVTABLE const *PCRTASN1COREVTABLE;
472
473
474/** @name Helper macros for prototyping standard functions for an ASN.1 type.
475 * @{ */
476
477#define RTASN1TYPE_STANDARD_PROTOTYPES_NO_GET_CORE(a_TypeNm, a_DeclMacro, a_ImplExtNm) \
478 a_DeclMacro(int) RT_CONCAT(a_ImplExtNm,_Init)(RT_CONCAT(P,a_TypeNm) pThis, PCRTASN1ALLOCATORVTABLE pAllocator); \
479 a_DeclMacro(int) RT_CONCAT(a_ImplExtNm,_Clone)(RT_CONCAT(P,a_TypeNm) pThis, RT_CONCAT(PC,a_TypeNm) pSrc, \
480 PCRTASN1ALLOCATORVTABLE pAllocator); \
481 a_DeclMacro(void) RT_CONCAT(a_ImplExtNm,_Delete)(RT_CONCAT(P,a_TypeNm) pThis); \
482 a_DeclMacro(int) RT_CONCAT(a_ImplExtNm,_Enum)(RT_CONCAT(P,a_TypeNm) pThis, PFNRTASN1ENUMCALLBACK pfnCallback, \
483 uint32_t uDepth, void *pvUser); \
484 a_DeclMacro(int) RT_CONCAT(a_ImplExtNm,_Compare)(RT_CONCAT(PC,a_TypeNm) pLeft, RT_CONCAT(PC,a_TypeNm) pRight); \
485 a_DeclMacro(int) RT_CONCAT(a_ImplExtNm,_DecodeAsn1)(PRTASN1CURSOR pCursor, uint32_t fFlags, RT_CONCAT(P,a_TypeNm) pThis,\
486 const char *pszErrorTag); \
487 a_DeclMacro(int) RT_CONCAT(a_ImplExtNm,_CheckSanity)(RT_CONCAT(PC,a_TypeNm) pThis, uint32_t fFlags, \
488 PRTERRINFO pErrInfo, const char *pszErrorTag)
489
490
491#define RTASN1TYPE_STANDARD_PROTOTYPES(a_TypeNm, a_DeclMacro, a_ImplExtNm, a_Asn1CoreNm) \
492 DECL_FORCE_INLINE(PRTASN1CORE) RT_CONCAT(a_ImplExtNm,_GetAsn1Core)(RT_CONCAT(PC,a_TypeNm) pThis) \
493 { return (PRTASN1CORE)&pThis->a_Asn1CoreNm; } \
494 DECLINLINE(bool) RT_CONCAT(a_ImplExtNm,_IsPresent)(RT_CONCAT(PC,a_TypeNm) pThis) \
495 { return pThis && RTASN1CORE_IS_PRESENT(&pThis->a_Asn1CoreNm); } \
496 RTASN1TYPE_STANDARD_PROTOTYPES_NO_GET_CORE(a_TypeNm, a_DeclMacro, a_ImplExtNm)
497
498
499/** Aliases two ASN.1 types, no method aliases. */
500#define RTASN1TYPE_ALIAS_TYPE_ONLY(a_TypeNm, a_AliasType) \
501 typedef a_AliasType a_TypeNm; \
502 typedef a_TypeNm *RT_CONCAT(P,a_TypeNm); \
503 typedef a_TypeNm const *RT_CONCAT(PC,a_TypeNm)
504
505/** Aliases two ASN.1 types and methods. */
506#define RTASN1TYPE_ALIAS(a_TypeNm, a_AliasType, a_ImplExtNm, a_AliasExtNm) \
507 typedef a_AliasType a_TypeNm; \
508 typedef a_TypeNm *RT_CONCAT(P,a_TypeNm); \
509 \
510 DECLINLINE(PRTASN1CORE) RT_CONCAT(a_ImplExtNm,_GetAsn1Core)(a_TypeNm const *pThis) \
511 { return RT_CONCAT(a_AliasExtNm,_GetAsn1Core)(pThis); } \
512 DECLINLINE(bool) RT_CONCAT(a_ImplExtNm,_IsPresent)(a_TypeNm const *pThis) \
513 { return RT_CONCAT(a_AliasExtNm,_IsPresent)(pThis); } \
514 \
515 DECLINLINE(int) RT_CONCAT(a_ImplExtNm,_Init)(RT_CONCAT(P,a_TypeNm) pThis, PCRTASN1ALLOCATORVTABLE pAllocator) \
516 { return RT_CONCAT(a_AliasExtNm,_Init)(pThis, pAllocator); } \
517 DECLINLINE(int) RT_CONCAT(a_ImplExtNm,_Clone)(RT_CONCAT(P,a_TypeNm) pThis, a_TypeNm const *pSrc, \
518 PCRTASN1ALLOCATORVTABLE pAllocator) \
519 { return RT_CONCAT(a_AliasExtNm,_Clone)(pThis, pSrc, pAllocator); } \
520 DECLINLINE(void) RT_CONCAT(a_ImplExtNm,_Delete)(RT_CONCAT(P,a_TypeNm) pThis) \
521 { RT_CONCAT(a_AliasExtNm,_Delete)(pThis); } \
522 DECLINLINE(int) RT_CONCAT(a_ImplExtNm,_Enum)(a_TypeNm *pThis, PFNRTASN1ENUMCALLBACK pfnCallback, \
523 uint32_t uDepth, void *pvUser) \
524 { return RT_CONCAT(a_AliasExtNm,_Enum)(pThis, pfnCallback, uDepth, pvUser); } \
525 DECLINLINE(int) RT_CONCAT(a_ImplExtNm,_Compare)(a_TypeNm const *pLeft, a_TypeNm const *pRight) \
526 { return RT_CONCAT(a_AliasExtNm,_Compare)(pLeft, pRight); } \
527 DECLINLINE(int) RT_CONCAT(a_ImplExtNm,_DecodeAsn1)(PRTASN1CURSOR pCursor, uint32_t fFlags, RT_CONCAT(P,a_TypeNm) pThis,\
528 const char *pszErrorTag) \
529 { return RT_CONCAT(a_AliasExtNm,_DecodeAsn1)(pCursor, fFlags, pThis, pszErrorTag); } \
530 DECLINLINE(int) RT_CONCAT(a_ImplExtNm,_CheckSanity)(a_TypeNm const *pThis, uint32_t fFlags, \
531 PRTERRINFO pErrInfo, const char *pszErrorTag) \
532 { return RT_CONCAT(a_AliasExtNm,_CheckSanity)(pThis, fFlags, pErrInfo, pszErrorTag); } \
533 \
534 typedef a_TypeNm const *RT_CONCAT(PC,a_TypeNm)
535
536/** @} */
537
538
539/**
540 * Core ASN.1 structure for storing encoding details and data location.
541 *
542 * This is used as a 'parent' for all other decoded ASN.1 based structures.
543 */
544typedef struct RTASN1CORE
545{
546 /** The tag.
547 * @remarks 32-bit should be enough for everyone... We don't currently
548 * implement decoding tags larger than 30 anyway. :-) */
549 uint32_t uTag;
550 /** Tag class and flags (ASN1_TAGCLASS_XXX and ASN1_TAGFLAG_XXX). */
551 uint8_t fClass;
552 /** The real tag value for IMPLICT tag overrides. */
553 uint8_t uRealTag;
554 /** The real class value for IMPLICT tag overrides. */
555 uint8_t fRealClass;
556 /** The size of the tag and length ASN.1 header. */
557 uint8_t cbHdr;
558 /** Length. */
559 uint32_t cb;
560 /** IPRT flags (RTASN1CORE_F_XXX). */
561 uint32_t fFlags;
562 /** Pointer to the data.
563 * After decoding this generally points to the encoded data content. When
564 * preparting something for encoding or otherwise constructing things in memory,
565 * this generally points heap memory or read-only constants.
566 * @sa RTAsn1ContentAllocZ, RTAsn1ContentReallocZ, RTAsn1ContentDup,
567 * RTAsn1ContentFree. */
568 RTCPTRUNION uData;
569 /** Pointer to the virtual method table for this object. Optional. */
570 PCRTASN1COREVTABLE pOps;
571} RTASN1CORE;
572/** The Vtable for a RTASN1CORE structure when not in some way use used as a
573 * parent type/class. */
574extern RTDATADECL(RTASN1COREVTABLE const) g_RTAsn1Core_Vtable;
575
576RTASN1TYPE_STANDARD_PROTOTYPES_NO_GET_CORE(RTASN1CORE, RTDECL, RTAsn1Core);
577
578/** @name RTASN1CORE_F_XXX - Flags for RTASN1CORE::fFlags
579 * @{ */
580/** Present/valid. */
581#define RTASN1CORE_F_PRESENT RT_BIT_32(0)
582/** Not present in stream, using default value. */
583#define RTASN1CORE_F_DEFAULT RT_BIT_32(1)
584/** The tag was overriden by an implict context tag or some such thing,
585 * RTASN1CORE::uImplicitTag hold the universal tag value if one exists. */
586#define RTASN1CORE_F_TAG_IMPLICIT RT_BIT_32(2)
587/** Primitive tag with the corresponding RTASN1XXX struct. */
588#define RTASN1CORE_F_PRIMITE_TAG_STRUCT RT_BIT_32(3)
589/** Dummy node typically used with choices, has children, not encoded, must be
590 * ignored. */
591#define RTASN1CORE_F_DUMMY RT_BIT_32(4)
592/** Allocated content (pointed to by uData).
593 * The content should is still be considered 104% read-only by anyone other
594 * than then type methods (pOps and associates). */
595#define RTASN1CORE_F_ALLOCATED_CONTENT RT_BIT_32(5)
596/** Decoded content (pointed to by uData).
597 * Mutually exclusive with RTASN1CORE_F_ALLOCATED_CONTENT. If neither is
598 * set, uData might be NULL or point to some shared static memory for
599 * frequently used values. */
600#define RTASN1CORE_F_DECODED_CONTENT RT_BIT_32(6)
601/** Indefinite length, still pending. */
602#define RTASN1CORE_F_INDEFINITE_LENGTH RT_BIT_32(7)
603/** @} */
604
605
606/** Checks whether an ASN.1 core object present in some way (default data,
607 * decoded data, ...). */
608#define RTASN1CORE_IS_PRESENT(a_pAsn1Core) ( RT_BOOL((a_pAsn1Core)->fFlags) )
609
610/** Checks whether an ASN.1 core object is a dummy object (and is present). */
611#define RTASN1CORE_IS_DUMMY(a_pAsn1Core) ( RT_BOOL((a_pAsn1Core)->fFlags & RTASN1CORE_F_DUMMY) )
612
613/**
614 * Calculates pointer to the raw ASN.1 record.
615 *
616 * ASSUMES that it's decoded content and that cbHdr and uData are both valid.
617 *
618 * @returns Byte pointer to the first tag byte.
619 * @param a_pAsn1Core The ASN.1 core.
620 */
621#define RTASN1CORE_GET_RAW_ASN1_PTR(a_pAsn1Core) ( (a_pAsn1Core)->uData.pu8 - (a_pAsn1Core)->cbHdr )
622
623/**
624 * Calculates the length of the raw ASN.1 record to go with the
625 * RTASN1CORE_GET_RAW_ASN1_PTR() result.
626 *
627 * ASSUMES that it's decoded content and that cbHdr and uData are both valid.
628 *
629 * @returns Size in bytes (uint32_t).
630 * @param a_pAsn1Core The ASN.1 core.
631 */
632#define RTASN1CORE_GET_RAW_ASN1_SIZE(a_pAsn1Core) ( (a_pAsn1Core)->cbHdr + (a_pAsn1Core)->cb )
633
634/**
635 * Retrievs the tag or implicit tag depending on the RTASN1CORE_F_TAG_IMPLICIT
636 * flag.
637 *
638 * @returns The ASN.1 tag of the object.
639 * @param a_pAsn1Core The ASN.1 core.
640 */
641#define RTASN1CORE_GET_TAG(a_pAsn1Core) ( !((a_pAsn1Core)->fFlags & RTASN1CORE_F_TAG_IMPLICIT) ? (a_pAsn1Core)->uTag : (a_pAsn1Core)->uRealTag )
642
643
644DECL_FORCE_INLINE(PRTASN1CORE) RTAsn1Core_GetAsn1Core(PCRTASN1CORE pThis)
645{
646 return (PRTASN1CORE)pThis;
647}
648
649
650DECL_FORCE_INLINE(bool) RTAsn1Core_IsPresent(PCRTASN1CORE pThis)
651{
652 return pThis && RTASN1CORE_IS_PRESENT(pThis);
653}
654
655
656RTDECL(int) RTAsn1Core_InitEx(PRTASN1CORE pAsn1Core, uint32_t uTag, uint8_t fClass, PCRTASN1COREVTABLE pOps, uint32_t fFlags);
657/**
658 * Initialize the ASN.1 core object representation to a default value.
659 *
660 * @returns VINF_SUCCESS
661 * @param pAsn1Core The ASN.1 core.
662 * @param uTag The tag number.
663 * @param fClass The tag class and flags.
664 */
665RTDECL(int) RTAsn1Core_InitDefault(PRTASN1CORE pAsn1Core, uint32_t uTag, uint8_t fClass);
666RTDECL(int) RTAsn1Core_CloneContent(PRTASN1CORE pThis, PCRTASN1CORE pSrc, PCRTASN1ALLOCATORVTABLE pAllocator);
667RTDECL(int) RTAsn1Core_CloneNoContent(PRTASN1CORE pThis, PCRTASN1CORE pSrc);
668RTDECL(int) RTAsn1Core_SetTagAndFlags(PRTASN1CORE pAsn1Core, uint32_t uTag, uint8_t fClass);
669RTDECL(int) RTAsn1Core_ChangeTag(PRTASN1CORE pAsn1Core, uint32_t uTag);
670RTDECL(void) RTAsn1Core_ResetImplict(PRTASN1CORE pThis);
671RTDECL(int) RTAsn1Core_CompareEx(PCRTASN1CORE pLeft, PCRTASN1CORE pRight, bool fIgnoreTagAndClass);
672
673
674/**
675 * Dummy ASN.1 object for use in choices and similar non-sequence structures.
676 *
677 * This allows hooking up destructors, enumerators and such, as well as not
678 * needing custom code for sequence-of / set-of collections.
679 */
680typedef struct RTASN1DUMMY
681{
682 /** Core ASN.1. */
683 RTASN1CORE Asn1Core;
684} RTASN1DUMMY;
685/** Pointer to a dummy record. */
686typedef RTASN1DUMMY *PRTASN1DUMMY;
687
688
689/**
690 * Initalizes a dummy ASN.1 object.
691 *
692 * @returns VINF_SUCCESS.
693 * @param pThis The dummy object.
694 */
695RTDECL(int) RTAsn1Dummy_InitEx(PRTASN1DUMMY pThis);
696
697/**
698 * Standard compliant initalizer.
699 *
700 * @returns VINF_SUCCESS.
701 * @param pThis The dummy object.
702 * @param pAllocator Ignored.
703 */
704DECLINLINE(int) RTAsn1Dummy_Init(PRTASN1DUMMY pThis, PCRTASN1ALLOCATORVTABLE pAllocator)
705{
706 NOREF(pAllocator);
707 return RTAsn1Dummy_InitEx(pThis);
708}
709
710
711/**
712 * ASN.1 sequence core (IPRT representation).
713 */
714typedef struct RTASN1SEQUENCECORE
715{
716 /** Core ASN.1 encoding details. */
717 RTASN1CORE Asn1Core;
718} RTASN1SEQUENCECORE;
719/** Pointer to an ASN.1 sequence core (IPRT representation). */
720typedef RTASN1SEQUENCECORE *PRTASN1SEQUENCECORE;
721/** Pointer to a const ASN.1 sequence core (IPRT representation). */
722typedef RTASN1SEQUENCECORE const *PCRTASN1SEQUENCECORE;
723
724RTDECL(int) RTAsn1SequenceCore_Init(PRTASN1SEQUENCECORE pSeqCore, PCRTASN1COREVTABLE pVtable);
725RTDECL(int) RTAsn1SequenceCore_Clone(PRTASN1SEQUENCECORE pSeqCore, PCRTASN1COREVTABLE pVtable, PCRTASN1SEQUENCECORE pSrc);
726
727/**
728 * ASN.1 sequence-of core (IPRT representation).
729 */
730#if 0
731typedef struct RTASN1SEQOFCORE
732{
733 /** Core ASN.1 encoding details. */
734 RTASN1CORE Asn1Core;
735} RTASN1SEQUENCECORE;
736/** Pointer to an ASN.1 sequence-of core (IPRT representation). */
737typedef RTASN1SEQUENCECORE *PRTASN1SEQUENCECORE;
738/** Pointer to a const ASN.1 sequence-of core (IPRT representation). */
739typedef RTASN1SEQUENCECORE const *PCRTASN1SEQUENCECORE;
740#else
741# define RTASN1SEQOFCORE RTASN1SEQUENCECORE
742# define PRTASN1SEQOFCORE PRTASN1SEQUENCECORE
743# define PCRTASN1SEQOFCORE PCRTASN1SEQUENCECORE
744#endif
745RTDECL(int) RTAsn1SeqOfCore_Init(PRTASN1SEQOFCORE pThis, PCRTASN1COREVTABLE pVtable);
746RTDECL(int) RTAsn1SeqOfCore_Clone(PRTASN1SEQOFCORE pThis, PCRTASN1COREVTABLE pVtable, PCRTASN1SEQOFCORE pSrc);
747
748
749/** Defines the typedefs and prototypes for a generic sequence-of/set-of type. */
750#define RTASN1_IMPL_GEN_SEQ_OR_SET_OF_TYPEDEFS_AND_PROTOS(a_CoreType, a_CoreMember, \
751 a_ThisType, a_ItemType, a_DeclMacro, a_ImplExtNm) \
752 typedef struct a_ThisType \
753 { \
754 /** Sequence/set core. */ \
755 a_CoreType a_CoreMember; \
756 /** The array allocation tracker. */ \
757 RTASN1ARRAYALLOCATION Allocation; \
758 /** Items in the array. */ \
759 uint32_t cItems; \
760 /** Array. */ \
761 RT_CONCAT(P,a_ItemType) *papItems; \
762 } a_ThisType; \
763 typedef a_ThisType *RT_CONCAT(P,a_ThisType); \
764 typedef a_ThisType const *RT_CONCAT(PC,a_ThisType); \
765 a_DeclMacro(int) RT_CONCAT(a_ImplExtNm,_Erase)(RT_CONCAT(P,a_ThisType) pThis, uint32_t iPosition); \
766 a_DeclMacro(int) RT_CONCAT(a_ImplExtNm,_InsertEx)(RT_CONCAT(P,a_ThisType) pThis, uint32_t iPosition, \
767 RT_CONCAT(PC,a_ItemType) pToClone, \
768 PCRTASN1ALLOCATORVTABLE pAllocator, uint32_t *piActualPos); \
769 /** Appends entry with default content, returns index or negative error code. */ \
770 DECLINLINE(int32_t) RT_CONCAT(a_ImplExtNm,_Append)(RT_CONCAT(P,a_ThisType) pThis) \
771 { \
772 uint32_t uPos = pThis->cItems; \
773 int rc = RT_CONCAT(a_ImplExtNm,_InsertEx)(pThis, uPos, NULL /*pToClone*/, pThis->Allocation.pAllocator, &uPos); \
774 if (RT_SUCCESS(rc)) \
775 return uPos; \
776 return rc; \
777 } \
778 RTASN1TYPE_STANDARD_PROTOTYPES(a_ThisType, a_DeclMacro, a_ImplExtNm, a_CoreMember.Asn1Core)
779
780/** Defines the typedefs and prototypes for a generic sequence-of type. */
781#define RTASN1_IMPL_GEN_SEQ_OF_TYPEDEFS_AND_PROTOS(a_SeqOfType, a_ItemType, a_DeclMacro, a_ImplExtNm) \
782 RTASN1_IMPL_GEN_SEQ_OR_SET_OF_TYPEDEFS_AND_PROTOS(RTASN1SEQUENCECORE, SeqCore, a_SeqOfType, a_ItemType, a_DeclMacro, a_ImplExtNm)
783
784
785/**
786 * ASN.1 set core (IPRT representation).
787 */
788typedef struct RTASN1SETCORE
789{
790 /** Core ASN.1 encoding details. */
791 RTASN1CORE Asn1Core;
792} RTASN1SETCORE;
793/** Pointer to an ASN.1 set core (IPRT representation). */
794typedef RTASN1SETCORE *PRTASN1SETCORE;
795/** Pointer to a const ASN.1 set core (IPRT representation). */
796typedef RTASN1SETCORE const *PCRTASN1SETCORE;
797
798RTDECL(int) RTAsn1SetCore_Init(PRTASN1SETCORE pThis, PCRTASN1COREVTABLE pVtable);
799RTDECL(int) RTAsn1SetCore_Clone(PRTASN1SETCORE pThis, PCRTASN1COREVTABLE pVtable, PCRTASN1SETCORE pSrc);
800
801/**
802 * ASN.1 set-of core (IPRT representation).
803 */
804#if 0
805typedef struct RTASN1SETOFCORE
806{
807 /** Core ASN.1 encoding details. */
808 RTASN1CORE Asn1Core;
809} RTASN1SETUENCECORE;
810/** Pointer to an ASN.1 set-of core (IPRT representation). */
811typedef RTASN1SETUENCECORE *PRTASN1SETUENCECORE;
812/** Pointer to a const ASN.1 set-of core (IPRT representation). */
813typedef RTASN1SETUENCECORE const *PCRTASN1SETUENCECORE;
814#else
815# define RTASN1SETOFCORE RTASN1SETCORE
816# define PRTASN1SETOFCORE PRTASN1SETCORE
817# define PCRTASN1SETOFCORE PCRTASN1SETCORE
818#endif
819RTDECL(int) RTAsn1SetOfCore_Init(PRTASN1SETOFCORE pThis, PCRTASN1COREVTABLE pVtable);
820RTDECL(int) RTAsn1SetOfCore_Clone(PRTASN1SETOFCORE pThis, PCRTASN1COREVTABLE pVtable, PCRTASN1SETOFCORE pSrc);
821
822
823/** Defines the typedefs and prototypes for a generic set-of type. */
824#define RTASN1_IMPL_GEN_SET_OF_TYPEDEFS_AND_PROTOS(a_SetOfType, a_ItemType, a_DeclMacro, a_ImplExtNm) \
825 RTASN1_IMPL_GEN_SEQ_OR_SET_OF_TYPEDEFS_AND_PROTOS(RTASN1SETCORE, SetCore, a_SetOfType, a_ItemType, a_DeclMacro, a_ImplExtNm)
826
827
828/*
829 * Declare sets and sequences of the core structure.
830 */
831RTASN1_IMPL_GEN_SEQ_OF_TYPEDEFS_AND_PROTOS(RTASN1SEQOFCORES, RTASN1CORE, RTDECL, RTAsn1SeqOfCores);
832RTASN1_IMPL_GEN_SET_OF_TYPEDEFS_AND_PROTOS(RTASN1SETOFCORES, RTASN1CORE, RTDECL, RTAsn1SetOfCores);
833
834
835/**
836 * ASN.1 null (IPRT representation).
837 */
838typedef struct RTASN1NULL
839{
840 /** Core ASN.1 encoding details. */
841 RTASN1CORE Asn1Core;
842} RTASN1NULL;
843/** Pointer to an ASN.1 null (IPRT representation). */
844typedef RTASN1NULL *PRTASN1NULL;
845/** Pointer to a const ASN.1 null (IPRT representation). */
846typedef RTASN1NULL const *PCRTASN1NULL;
847/** The Vtable for a RTASN1NULL structure. */
848extern RTDATADECL(RTASN1COREVTABLE const) g_RTAsn1Null_Vtable;
849
850RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1NULL, RTDECL, RTAsn1Null, Asn1Core);
851
852
853/**
854 * ASN.1 integer (IPRT representation).
855 */
856typedef struct RTASN1INTEGER
857{
858 /** Core ASN.1 encoding details. */
859 RTASN1CORE Asn1Core;
860 /** The unsigned C representation of the 64 least significant bits.
861 * @note A ASN.1 integer doesn't define signed/unsigned and can have any
862 * length you like. Thus, the user needs to check the size and
863 * preferably use the access APIs for signed numbers. */
864 RTUINT64U uValue;
865} RTASN1INTEGER;
866/** Pointer to an ASN.1 integer (IPRT representation). */
867typedef RTASN1INTEGER *PRTASN1INTEGER;
868/** Pointer to a const ASN.1 integer (IPRT representation). */
869typedef RTASN1INTEGER const *PCRTASN1INTEGER;
870/** The Vtable for a RTASN1INTEGER structure. */
871extern RTDATADECL(RTASN1COREVTABLE const) g_RTAsn1Integer_Vtable;
872
873RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1INTEGER, RTDECL, RTAsn1Integer, Asn1Core);
874
875/**
876 * Initializes an interger object to a default value.
877 * @returns VINF_SUCCESS.
878 * @param pInteger The integer object representation.
879 * @param uValue The default value (unsigned 64-bit).
880 * @param pAllocator The allocator (pro forma).
881 */
882RTDECL(int) RTAsn1Integer_InitDefault(PRTASN1INTEGER pInteger, uint64_t uValue, PCRTASN1ALLOCATORVTABLE pAllocator);
883
884RTDECL(int) RTAsn1Integer_InitU64(PRTASN1INTEGER pThis, uint64_t uValue, PCRTASN1ALLOCATORVTABLE pAllocator);
885
886/**
887 * Get the most significat bit that's set (1).
888 *
889 * @returns 0-base bit number, -1 if all clear.
890 * @param pInteger The integer to check.
891 */
892RTDECL(int32_t) RTAsn1Integer_UnsignedLastBit(PCRTASN1INTEGER pInteger);
893
894/**
895 * Compares two ASN.1 unsigned integers.
896 *
897 * @returns 0 if equal, -1 if @a pLeft is smaller, 1 if @a pLeft is larger.
898 * @param pLeft The first ASN.1 integer.
899 * @param pRight The second ASN.1 integer.
900 */
901RTDECL(int) RTAsn1Integer_UnsignedCompare(PCRTASN1INTEGER pLeft, PCRTASN1INTEGER pRight);
902
903/**
904 * Compares an ASN.1 unsigned integer with a uint64_t.
905 *
906 * @returns 0 if equal, -1 if @a pInteger is smaller, 1 if @a pInteger is
907 * larger.
908 * @param pInteger The ASN.1 integer to treat as unsigned.
909 * @param u64Const The uint64_t constant to compare with.
910 */
911RTDECL(int) RTAsn1Integer_UnsignedCompareWithU64(PCRTASN1INTEGER pInteger, uint64_t u64Const);
912
913/**
914 * Compares an ASN.1 unsigned integer with a uint32_t.
915 *
916 * @returns 0 if equal, -1 if @a pInteger is smaller, 1 if @a pInteger is
917 * larger.
918 * @param pInteger The ASN.1 integer to treat as unsigned.
919 * @param u32Const The uint32_t constant to compare with.
920 * @remarks We don't bother with U16 and U8 variants, just use this instead.
921 */
922RTDECL(int) RTAsn1Integer_UnsignedCompareWithU32(PCRTASN1INTEGER pInteger, uint32_t u32Const);
923
924
925/**
926 * Initializes a big integer number from an ASN.1 integer.
927 *
928 * @returns IPRT status code.
929 * @param pInteger The ASN.1 integer.
930 * @param pBigNum The big integer number structure to initialize.
931 * @param fBigNumInit Subset of RTBIGNUMINIT_F_XXX that concerns
932 * senitivity, signedness and endianness.
933 */
934RTDECL(int) RTAsn1Integer_ToBigNum(PCRTASN1INTEGER pInteger, PRTBIGNUM pBigNum, uint32_t fBigNumInit);
935RTDECL(int) RTAsn1Integer_FromBigNum(PRTASN1INTEGER pThis, PCRTBIGNUM pBigNum, PCRTASN1ALLOCATORVTABLE pAllocator);
936
937/**
938 * Converts the integer to a string.
939 *
940 * This will produce a hex represenation of the number. If it fits in 64-bit, a
941 * C style hex number will be produced. If larger than 64-bit, it will be
942 * printed as a space separated string of hex bytes.
943 *
944 * @returns IPRT status code.
945 * @param pThis The ASN.1 integer.
946 * @param pszBuf The output buffer.
947 * @param cbBuf The buffer size.
948 * @param fFlags Flags reserved for future exploits. MBZ.
949 * @param pcbActual Where to return the amount of buffer space used
950 * (i.e. including terminator). Optional.
951 *
952 * @remarks Currently assume unsigned number.
953 */
954RTDECL(int) RTAsn1Integer_ToString(PRTASN1INTEGER pThis, char *pszBuf, size_t cbBuf, uint32_t fFlags, size_t *pcbActual);
955
956RTASN1_IMPL_GEN_SEQ_OF_TYPEDEFS_AND_PROTOS(RTASN1SEQOFINTEGERS, RTASN1INTEGER, RTDECL, RTAsn1SeqOfIntegers);
957RTASN1_IMPL_GEN_SET_OF_TYPEDEFS_AND_PROTOS(RTASN1SETOFINTEGERS, RTASN1INTEGER, RTDECL, RTAsn1SetOfIntegers);
958
959
960
961/**
962 * ASN.1 boolean (IPRT representation).
963 */
964typedef struct RTASN1BOOLEAN
965{
966 /** Core ASN.1 encoding details. */
967 RTASN1CORE Asn1Core;
968 /** The boolean value. */
969 bool fValue;
970} RTASN1BOOLEAN;
971/** Pointer to the IPRT representation of an ASN.1 boolean. */
972typedef RTASN1BOOLEAN *PRTASN1BOOLEAN;
973/** Pointer to the const IPRT representation of an ASN.1 boolean. */
974typedef RTASN1BOOLEAN const *PCRTASN1BOOLEAN;
975/** The Vtable for a RTASN1BOOLEAN structure. */
976extern RTDATADECL(RTASN1COREVTABLE const) g_RTAsn1Boolean_Vtable;
977
978RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1BOOLEAN, RTDECL, RTAsn1Boolean, Asn1Core);
979
980/**
981 * Initializes a boolean object to a default value.
982 * @returns VINF_SUCCESS
983 * @param pBoolean The boolean object representation.
984 * @param fValue The default value.
985 * @param pAllocator The allocator (pro forma).
986 */
987RTDECL(int) RTAsn1Boolean_InitDefault(PRTASN1BOOLEAN pBoolean, bool fValue, PCRTASN1ALLOCATORVTABLE pAllocator);
988RTDECL(int) RTAsn1Boolean_Set(PRTASN1BOOLEAN pThis, bool fValue);
989
990RTASN1_IMPL_GEN_SEQ_OF_TYPEDEFS_AND_PROTOS(RTASN1SEQOFBOOLEANS, RTASN1BOOLEAN, RTDECL, RTAsn1SeqOfBooleans);
991RTASN1_IMPL_GEN_SET_OF_TYPEDEFS_AND_PROTOS(RTASN1SETOFBOOLEANS, RTASN1BOOLEAN, RTDECL, RTAsn1SetOfBooleans);
992
993
994
995/**
996 * ASN.1 UTC and Generalized Time (IPRT representation).
997 *
998 * The two time types only differs in the precision the render (UTC time being
999 * the one for which you go "WTF were they thinking?!!" for in 2014).
1000 */
1001typedef struct RTASN1TIME
1002{
1003 /** The core structure, either ASN1_TAG_UTC_TIME or
1004 * ASN1_TAG_GENERALIZED_TIME. */
1005 RTASN1CORE Asn1Core;
1006 /** The exploded time. */
1007 RTTIME Time;
1008} RTASN1TIME;
1009/** Pointer to an IPRT representation of ASN.1 UTC/Generalized time. */
1010typedef RTASN1TIME *PRTASN1TIME;
1011/** Pointer to a const IPRT representation of ASN.1 UTC/Generalized time. */
1012typedef RTASN1TIME const *PCRTASN1TIME;
1013/** The Vtable for a RTASN1TIME structure. */
1014extern RTDATADECL(RTASN1COREVTABLE const) g_RTAsn1Time_Vtable;
1015
1016RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1TIME, RTDECL, RTAsn1Time, Asn1Core);
1017
1018RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1TIME, RTDECL, RTAsn1UtcTime, Asn1Core);
1019RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1TIME, RTDECL, RTAsn1GeneralizedTime, Asn1Core);
1020
1021/**
1022 * Compares two ASN.1 time values.
1023 *
1024 * @returns 0 if equal, -1 if @a pLeft is smaller, 1 if @a pLeft is larger.
1025 * @param pLeft The first ASN.1 time object.
1026 * @param pTsRight The second time to compare.
1027 */
1028RTDECL(int) RTAsn1Time_CompareWithTimeSpec(PCRTASN1TIME pLeft, PCRTTIMESPEC pTsRight);
1029
1030RTDECL(int) RTAsn1Time_InitEx(PRTASN1TIME pThis, uint32_t uTag, PCRTASN1ALLOCATORVTABLE pAllocator);
1031
1032/** @name Predicate macros for determing the exact type of RTASN1TIME.
1033 * @{ */
1034/** True if UTC time. */
1035#define RTASN1TIME_IS_UTC_TIME(a_pAsn1Time) ((a_pAsn1Time)->Asn1Core.uTag == ASN1_TAG_UTC_TIME)
1036/** True if generalized time. */
1037#define RTASN1TIME_IS_GENERALIZED_TIME(a_pAsn1Time) ((a_pAsn1Time)->Asn1Core.uTag == ASN1_TAG_GENERALIZED_TIME)
1038/** @} */
1039
1040RTASN1_IMPL_GEN_SEQ_OF_TYPEDEFS_AND_PROTOS(RTASN1SEQOFTIMES, RTASN1TIME, RTDECL, RTAsn1SeqOfTimes);
1041RTASN1_IMPL_GEN_SET_OF_TYPEDEFS_AND_PROTOS(RTASN1SETOFTIMES, RTASN1TIME, RTDECL, RTAsn1SetOfTimes);
1042
1043
1044
1045/**
1046 * ASN.1 object identifier (IPRT representation).
1047 */
1048typedef struct RTASN1OBJID
1049{
1050 /** Core ASN.1 encoding details. */
1051 RTASN1CORE Asn1Core;
1052 /** Coverning the paComponents memory allocation if there isn't enough room in
1053 * szObjId for both the dottet string and the component values. */
1054 RTASN1ALLOCATION Allocation;
1055 /** Pointer to an array with the component values.
1056 * This may point within szObjId if there is enough space for both there. */
1057 uint32_t const *pauComponents;
1058 /** The number of components in the object identifier.
1059 * This ASSUMES that nobody will be ever needing more than 255 components. */
1060 uint8_t cComponents;
1061 /** The dotted string representation of the object identifier.
1062 * If there is sufficient space after the string, we will place the array that
1063 * paComponents points to here and/or the raw content bytes (Asn1Core.uData).
1064 *
1065 * An analysis of dumpasn1.cfg, hl7.org and our own _OID defines indicates
1066 * that we need space for at least 10 components and 30-something chars. We've
1067 * allocated 87 bytes, which we ASSUME should be enough for everyone. */
1068 char szObjId[87];
1069} RTASN1OBJID;
1070/** Pointer to an ASN.1 object identifier representation. */
1071typedef RTASN1OBJID *PRTASN1OBJID;
1072/** Pointer to a const ASN.1 object identifier representation. */
1073typedef RTASN1OBJID const *PCRTASN1OBJID;
1074/** The Vtable for a RTASN1OBJID structure. */
1075extern RTDATADECL(RTASN1COREVTABLE const) g_RTAsn1ObjId_Vtable;
1076
1077RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1OBJID, RTDECL, RTAsn1ObjId, Asn1Core);
1078
1079RTDECL(int) RTAsn1ObjId_InitFromString(PRTASN1OBJID pThis, const char *pszObjId, PCRTASN1ALLOCATORVTABLE pAllocator);
1080
1081/**
1082 * Compares an ASN.1 object identifier with a dotted object identifier string.
1083 *
1084 * @returns 0 if equal, -1 if @a pLeft is smaller, 1 if @a pLeft is larger.
1085 * @param pThis The ASN.1 object identifier.
1086 * @param pszRight The dotted object identifier string.
1087 */
1088RTDECL(int) RTAsn1ObjId_CompareWithString(PCRTASN1OBJID pThis, const char *pszRight);
1089
1090/**
1091 * Checks if an ASN.1 object identifier starts with the given dotted object
1092 * identifier string.
1093 *
1094 * The matching is only successful if the given string matches matches the last
1095 * component completely.
1096 *
1097 * @returns true / false.
1098 * @param pThis The ASN.1 object identifier.
1099 * @param pszStartsWith The dotted object identifier string.
1100 */
1101RTDECL(bool) RTAsn1ObjId_StartsWith(PCRTASN1OBJID pThis, const char *pszStartsWith);
1102
1103RTDECL(uint8_t) RTAsn1ObjIdCountComponents(PCRTASN1OBJID pThis);
1104RTDECL(uint32_t) RTAsn1ObjIdGetComponentsAsUInt32(PCRTASN1OBJID pThis, uint8_t iComponent);
1105RTDECL(uint32_t) RTAsn1ObjIdGetLastComponentsAsUInt32(PCRTASN1OBJID pThis);
1106
1107RTASN1_IMPL_GEN_SEQ_OF_TYPEDEFS_AND_PROTOS(RTASN1SEQOFOBJIDS, RTASN1OBJID, RTDECL, RTAsn1SeqOfObjIds);
1108RTASN1_IMPL_GEN_SET_OF_TYPEDEFS_AND_PROTOS(RTASN1SETOFOBJIDS, RTASN1OBJID, RTDECL, RTAsn1SetOfObjIds);
1109RTASN1_IMPL_GEN_SET_OF_TYPEDEFS_AND_PROTOS(RTASN1SETOFOBJIDSEQS, RTASN1SEQOFOBJIDS, RTDECL, RTAsn1SetOfObjIdSeqs);
1110
1111
1112/**
1113 * ASN.1 bit string (IPRT representation).
1114 */
1115typedef struct RTASN1BITSTRING
1116{
1117 /** Core ASN.1 encoding details. */
1118 RTASN1CORE Asn1Core;
1119 /** The number of bits. */
1120 uint32_t cBits;
1121 /** The max number of bits (given at decoding / construction). */
1122 uint32_t cMaxBits;
1123 /** Pointer to the bits. */
1124 RTCPTRUNION uBits;
1125 /** Pointer to user structure encapsulated in this string, if dynamically
1126 * allocated the EncapsulatedAllocation member can be used to track it and
1127 * trigger automatic cleanup on object destruction. If EncapsulatedAllocation
1128 * is zero, any object pointed to will only be deleted. */
1129 PRTASN1CORE pEncapsulated;
1130 /** Allocation tracking structure for pEncapsulated. */
1131 RTASN1ALLOCATION EncapsulatedAllocation;
1132} RTASN1BITSTRING;
1133/** Pointer to the IPRT representation of an ASN.1 bit string. */
1134typedef RTASN1BITSTRING *PRTASN1BITSTRING;
1135/** Pointer to the const IPRT representation of an ASN.1 bit string. */
1136typedef RTASN1BITSTRING const *PCRTASN1BITSTRING;
1137/** The Vtable for a RTASN1BITSTRING structure. */
1138extern RTDATADECL(RTASN1COREVTABLE const) g_RTAsn1BitString_Vtable;
1139
1140RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1BITSTRING, RTDECL, RTAsn1BitString, Asn1Core);
1141
1142/**
1143 * Calculates pointer to the first bit.
1144 *
1145 * @returns Byte pointer to the first bit.
1146 * @param a_pBitString The ASN.1 bit string.
1147 */
1148#define RTASN1BITSTRING_GET_BIT0_PTR(a_pBitString) ( &(a_pBitString)->Asn1Core.uData.pu8[1] )
1149
1150/**
1151 * Calculates the size in bytes.
1152 *
1153 * @returns Rounded up size in bytes.
1154 * @param a_pBitString The ASN.1 bit string.
1155 */
1156#define RTASN1BITSTRING_GET_BYTE_SIZE(a_pBitString) ( ((a_pBitString)->cBits + 7U) >> 3 )
1157
1158RTDECL(int) RTAsn1BitString_DecodeAsn1Ex(PRTASN1CURSOR pCursor, uint32_t fFlags, uint32_t cMaxBits, PRTASN1BITSTRING pThis,
1159 const char *pszErrorTag);
1160RTDECL(uint64_t) RTAsn1BitString_GetAsUInt64(PCRTASN1BITSTRING pThis);
1161RTDECL(int) RTAsn1BitString_RefreshContent(PRTASN1BITSTRING pThis, uint32_t fFlags,
1162 PCRTASN1ALLOCATORVTABLE pAllocator, PRTERRINFO pErrInfo);
1163RTDECL(bool) RTAsn1BitString_AreContentBitsValid(PCRTASN1BITSTRING pThis, uint32_t fFlags);
1164
1165RTASN1_IMPL_GEN_SEQ_OF_TYPEDEFS_AND_PROTOS(RTASN1SEQOFBITSTRINGS, RTASN1BITSTRING, RTDECL, RTAsn1SeqOfBitStrings);
1166RTASN1_IMPL_GEN_SET_OF_TYPEDEFS_AND_PROTOS(RTASN1SETOFBITSTRINGS, RTASN1BITSTRING, RTDECL, RTAsn1SetOfBitStrings);
1167
1168
1169/**
1170 * ASN.1 octet string (IPRT representation).
1171 */
1172typedef struct RTASN1OCTETSTRING
1173{
1174 /** Core ASN.1 encoding details. */
1175 RTASN1CORE Asn1Core;
1176 /** Pointer to user structure encapsulated in this string.
1177 *
1178 * If dynamically allocated the EncapsulatedAllocation member can be used to
1179 * track it and trigger automatic cleanup on object destruction. If
1180 * EncapsulatedAllocation is zero, any object pointed to will only be
1181 * deleted. */
1182 PRTASN1CORE pEncapsulated;
1183 /** Allocation tracking structure for pEncapsulated. */
1184 RTASN1ALLOCATION EncapsulatedAllocation;
1185} RTASN1OCTETSTRING;
1186/** Pointer to the IPRT representation of an ASN.1 octet string. */
1187typedef RTASN1OCTETSTRING *PRTASN1OCTETSTRING;
1188/** Pointer to the const IPRT representation of an ASN.1 octet string. */
1189typedef RTASN1OCTETSTRING const *PCRTASN1OCTETSTRING;
1190/** The Vtable for a RTASN1OCTETSTRING structure. */
1191extern RTDATADECL(RTASN1COREVTABLE const) g_RTAsn1OctetString_Vtable;
1192
1193RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1OCTETSTRING, RTDECL, RTAsn1OctetString, Asn1Core);
1194
1195RTDECL(bool) RTAsn1OctetString_AreContentBytesValid(PCRTASN1OCTETSTRING pThis, uint32_t fFlags);
1196RTDECL(int) RTAsn1OctetString_RefreshContent(PRTASN1OCTETSTRING pThis, uint32_t fFlags,
1197 PCRTASN1ALLOCATORVTABLE pAllocator, PRTERRINFO pErrInfo);
1198
1199RTASN1_IMPL_GEN_SEQ_OF_TYPEDEFS_AND_PROTOS(RTASN1SEQOFOCTETSTRINGS, RTASN1OCTETSTRING, RTDECL, RTAsn1SeqOfOctetStrings);
1200RTASN1_IMPL_GEN_SET_OF_TYPEDEFS_AND_PROTOS(RTASN1SETOFOCTETSTRINGS, RTASN1OCTETSTRING, RTDECL, RTAsn1SetOfOctetStrings);
1201
1202
1203/**
1204 * ASN.1 string (IPRT representation).
1205 * All char string types except 'character string (29)'.
1206 */
1207typedef struct RTASN1STRING
1208{
1209 /** Core ASN.1 encoding details. */
1210 RTASN1CORE Asn1Core;
1211 /** Allocation tracking for pszUtf8. */
1212 RTASN1ALLOCATION Allocation;
1213 /** If conversion to UTF-8 was requested, we cache that here. */
1214 char const *pszUtf8;
1215 /** The length (chars, not code points) of the above UTF-8 string if
1216 * present. */
1217 uint32_t cchUtf8;
1218} RTASN1STRING;
1219/** Pointer to the IPRT representation of an ASN.1 string. */
1220typedef RTASN1STRING *PRTASN1STRING;
1221/** Pointer to the const IPRT representation of an ASN.1 string. */
1222typedef RTASN1STRING const *PCRTASN1STRING;
1223/** The Vtable for a RTASN1STRING structure. */
1224extern RTDATADECL(RTASN1COREVTABLE const) g_RTAsn1String_Vtable;
1225
1226RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1String, Asn1Core);
1227
1228/** @name String type predicate macros.
1229 * @{ */
1230#define RTASN1STRING_IS_NUMERIC(a_pAsn1String) ( RTASN1CORE_GET_TAG(&(a_pAsn1String)->Asn1Core) == ASN1_TAG_NUMERIC_STRING )
1231#define RTASN1STRING_IS_PRINTABLE(a_pAsn1String) ( RTASN1CORE_GET_TAG(&(a_pAsn1String)->Asn1Core) == ASN1_TAG_PRINTABLE_STRING )
1232#define RTASN1STRING_IS_T61(a_pAsn1String) ( RTASN1CORE_GET_TAG(&(a_pAsn1String)->Asn1Core) == ASN1_TAG_T61_STRING )
1233#define RTASN1STRING_IS_VIDEOTEX(a_pAsn1String) ( RTASN1CORE_GET_TAG(&(a_pAsn1String)->Asn1Core) == ASN1_TAG_VIDEOTEX_STRING )
1234#define RTASN1STRING_IS_VISIBLE(a_pAsn1String) ( RTASN1CORE_GET_TAG(&(a_pAsn1String)->Asn1Core) == ASN1_TAG_VISIBLE_STRING )
1235#define RTASN1STRING_IS_IA5(a_pAsn1String) ( RTASN1CORE_GET_TAG(&(a_pAsn1String)->Asn1Core) == ASN1_TAG_IA5_STRING )
1236#define RTASN1STRING_IS_GRAPHIC(a_pAsn1String) ( RTASN1CORE_GET_TAG(&(a_pAsn1String)->Asn1Core) == ASN1_TAG_GRAPHIC_STRING )
1237#define RTASN1STRING_IS_GENERAL(a_pAsn1String) ( RTASN1CORE_GET_TAG(&(a_pAsn1String)->Asn1Core) == ASN1_TAG_GENERAL_STRING )
1238/** UTF-8. */
1239#define RTASN1STRING_IS_UTF8(a_pAsn1String) ( RTASN1CORE_GET_TAG(&(a_pAsn1String)->Asn1Core) == ASN1_TAG_UTF8_STRING )
1240/** UCS-2. */
1241#define RTASN1STRING_IS_BMP(a_pAsn1String) ( RTASN1CORE_GET_TAG(&(a_pAsn1String)->Asn1Core) == ASN1_TAG_BMP_STRING )
1242/** UCS-4. */
1243#define RTASN1STRING_IS_UNIVERSAL(a_pAsn1String) ( RTASN1CORE_GET_TAG(&(a_pAsn1String)->Asn1Core) == ASN1_TAG_UNIVERSAL_STRING )
1244/** @} */
1245
1246RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1NumericString, Asn1Core);
1247RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1PrintableString, Asn1Core);
1248RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1T61String, Asn1Core);
1249RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1VideoTexString, Asn1Core);
1250RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1VisibleString, Asn1Core);
1251RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1Ia5String, Asn1Core);
1252RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1GraphicString, Asn1Core);
1253RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1GeneralString, Asn1Core);
1254RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1Utf8String, Asn1Core);
1255RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1BmpString, Asn1Core);
1256RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1UniversalString, Asn1Core);
1257
1258RTDECL(int) RTAsn1String_InitWithValue(PRTASN1STRING pThis, const char *pszUtf8Value, PCRTASN1ALLOCATORVTABLE pAllocator);
1259RTDECL(int) RTAsn1String_InitEx(PRTASN1STRING pThis, uint32_t uTag, void const *pvValue, size_t cbValue,
1260 PCRTASN1ALLOCATORVTABLE pAllocator);
1261
1262/**
1263 * Compares two strings values, extended version.
1264 *
1265 * @returns 0 if equal, -1 if @a pLeft is smaller, 1 if @a pLeft is larger.
1266 * @param pLeft The first string.
1267 * @param pRight The second string.
1268 * @param fTypeToo Set if the string types must match, false if
1269 * not.
1270 */
1271RTDECL(int) RTAsn1String_CompareEx(PCRTASN1STRING pLeft, PCRTASN1STRING pRight, bool fTypeToo);
1272RTDECL(int) RTAsn1String_CompareValues(PCRTASN1STRING pLeft, PCRTASN1STRING pRight);
1273
1274/**
1275 * Compares a ASN.1 string object with an UTF-8 string.
1276 *
1277 * @returns 0 if equal, -1 if @a pThis is smaller, 1 if @a pThis is larger.
1278 * @param pThis The ASN.1 string object.
1279 * @param pszString The UTF-8 string.
1280 * @param cchString The length of @a pszString, or RTSTR_MAX.
1281 */
1282RTDECL(int) RTAsn1String_CompareWithString(PCRTASN1STRING pThis, const char *pszString, size_t cchString);
1283
1284/**
1285 * Queries the UTF-8 length of an ASN.1 string object.
1286 *
1287 * This differs from RTAsn1String_QueryUtf8 in that it won't need to allocate
1288 * memory for the converted string, but just calculates the length.
1289 *
1290 * @returns IPRT status code.
1291 * @param pThis The ASN.1 string object.
1292 * @param pcch Where to return the string length.
1293 */
1294RTDECL(int) RTAsn1String_QueryUtf8Len(PCRTASN1STRING pThis, size_t *pcch);
1295
1296/**
1297 * Queries the UTF-8 string for an ASN.1 string object.
1298 *
1299 * This may fail as it may require memory to be allocated for storing the
1300 * string.
1301 *
1302 * @returns IPRT status code.
1303 * @param pString The ASN.1 string object. This is a const
1304 * parameter for making life easier on the caller,
1305 * however be aware that the object may be modified
1306 * by this call!
1307 * @param ppsz Where to return the pointer to the UTF-8 string.
1308 * Optional.
1309 * @param pcch Where to return the length (in 8-bit chars) to
1310 * of the UTF-8 string. Optional.
1311 */
1312RTDECL(int) RTAsn1String_QueryUtf8(PCRTASN1STRING pString, const char **ppsz, size_t *pcch);
1313RTDECL(int) RTAsn1String_RecodeAsUtf8(PRTASN1STRING pThis, PCRTASN1ALLOCATORVTABLE pAllocator);
1314
1315RTASN1_IMPL_GEN_SEQ_OF_TYPEDEFS_AND_PROTOS(RTASN1SEQOFSTRINGS, RTASN1STRING, RTDECL, RTAsn1SeqOfStrings);
1316RTASN1_IMPL_GEN_SET_OF_TYPEDEFS_AND_PROTOS(RTASN1SETOFSTRINGS, RTASN1STRING, RTDECL, RTAsn1SetOfStrings);
1317
1318
1319
1320/**
1321 * ASN.1 generic context specific tag (IPRT representation).
1322 *
1323 * Normally used to tag something that's optional, version specific or such.
1324 *
1325 * For the purpose of documenting the format with typedefs as well as possibly
1326 * making it a little more type safe, there's a set of typedefs for the most
1327 * commonly used tag values defined. These typedefs have are identical to
1328 * RTASN1CONTEXTTAG, except from the C++ type system point of view.
1329 */
1330typedef struct RTASN1CONTEXTTAG
1331{
1332 /** Core ASN.1 encoding details. */
1333 RTASN1CORE Asn1Core;
1334} RTASN1CONTEXTTAG;
1335/** Pointer to an ASN.1 context tag (IPRT thing). */
1336typedef RTASN1CONTEXTTAG *PRTASN1CONTEXTTAG;
1337/** Pointer to a const ASN.1 context tag (IPRT thing). */
1338typedef RTASN1CONTEXTTAG const *PCRTASN1CONTEXTTAG;
1339
1340RTDECL(int) RTAsn1ContextTagN_Init(PRTASN1CONTEXTTAG pThis, uint32_t uTag, PCRTASN1COREVTABLE pVtable);
1341RTDECL(int) RTAsn1ContextTagN_Clone(PRTASN1CONTEXTTAG pThis, PCRTASN1CONTEXTTAG pSrc, uint32_t uTag);
1342
1343
1344/** @internal */
1345#define RTASN1CONTEXTTAG_DO_TYPEDEF_AND_INLINE(a_uTag) \
1346 typedef struct RT_CONCAT(RTASN1CONTEXTTAG,a_uTag) { RTASN1CORE Asn1Core; } RT_CONCAT(RTASN1CONTEXTTAG,a_uTag); \
1347 typedef RT_CONCAT(RTASN1CONTEXTTAG,a_uTag) *RT_CONCAT(PRTASN1CONTEXTTAG,a_uTag); \
1348 DECLINLINE(int) RT_CONCAT3(RTAsn1ContextTag,a_uTag,_Init)(RT_CONCAT(PRTASN1CONTEXTTAG,a_uTag) pThis, \
1349 PCRTASN1COREVTABLE pVtable, PCRTASN1ALLOCATORVTABLE pAllocator) \
1350 { \
1351 NOREF(pAllocator); \
1352 return RTAsn1ContextTagN_Init((PRTASN1CONTEXTTAG)pThis, a_uTag, pVtable); \
1353 } \
1354 DECLINLINE(int) RT_CONCAT3(RTAsn1ContextTag,a_uTag,_Clone)(RT_CONCAT(PRTASN1CONTEXTTAG,a_uTag) pThis, \
1355 RT_CONCAT(RTASN1CONTEXTTAG,a_uTag) const *pSrc) \
1356 { return RTAsn1ContextTagN_Clone((PRTASN1CONTEXTTAG)pThis, (PCRTASN1CONTEXTTAG)pSrc, a_uTag); } \
1357 typedef RT_CONCAT(RTASN1CONTEXTTAG,a_uTag) const *RT_CONCAT(PCRTASN1CONTEXTTAG,a_uTag)
1358RTASN1CONTEXTTAG_DO_TYPEDEF_AND_INLINE(0);
1359RTASN1CONTEXTTAG_DO_TYPEDEF_AND_INLINE(1);
1360RTASN1CONTEXTTAG_DO_TYPEDEF_AND_INLINE(2);
1361RTASN1CONTEXTTAG_DO_TYPEDEF_AND_INLINE(3);
1362RTASN1CONTEXTTAG_DO_TYPEDEF_AND_INLINE(4);
1363RTASN1CONTEXTTAG_DO_TYPEDEF_AND_INLINE(5);
1364RTASN1CONTEXTTAG_DO_TYPEDEF_AND_INLINE(6);
1365RTASN1CONTEXTTAG_DO_TYPEDEF_AND_INLINE(7);
1366#undef RTASN1CONTEXTTAG_DO_TYPEDEF_AND_INLINE
1367
1368/** Helper for comparing optional context tags.
1369 * This will return if both are not present or if their precense differs.
1370 * @internal */
1371#define RTASN1CONTEXTTAG_COMPARE_PRESENT_RETURN_INTERNAL(a_iDiff, a_pLeft, a_pRight, a_uTag) \
1372 do { \
1373 /* type checks */ \
1374 RT_CONCAT(PCRTASN1CONTEXTTAG,a_uTag) const pMyLeftInternal = (a_pLeft); \
1375 RT_CONCAT(PCRTASN1CONTEXTTAG,a_uTag) const pMyRightInternal = (a_pRight); \
1376 (a_iDiff) = (int)RTASN1CORE_IS_PRESENT(&pMyLeftInternal->Asn1Core) \
1377 - (int)RTASN1CORE_IS_PRESENT(&pMyRightInternal->Asn1Core); \
1378 if ((a_iDiff) || !RTASN1CORE_IS_PRESENT(&pMyLeftInternal->Asn1Core)) return iDiff; \
1379 } while (0)
1380
1381/** @name Helpers for comparing optional context tags.
1382 * This will return if both are not present or if their precense differs.
1383 * @{ */
1384#define RTASN1CONTEXTTAG0_COMPARE_PRESENT_RETURN(a_iDiff, a_pLeft, a_pRight) RTASN1CONTEXTTAG_COMPARE_PRESENT_RETURN_INTERNAL(a_iDiff, a_pLeft, a_pRight, 0)
1385#define RTASN1CONTEXTTAG1_COMPARE_PRESENT_RETURN(a_iDiff, a_pLeft, a_pRight) RTASN1CONTEXTTAG_COMPARE_PRESENT_RETURN_INTERNAL(a_iDiff, a_pLeft, a_pRight, 1)
1386#define RTASN1CONTEXTTAG2_COMPARE_PRESENT_RETURN(a_iDiff, a_pLeft, a_pRight) RTASN1CONTEXTTAG_COMPARE_PRESENT_RETURN_INTERNAL(a_iDiff, a_pLeft, a_pRight, 2)
1387#define RTASN1CONTEXTTAG3_COMPARE_PRESENT_RETURN(a_iDiff, a_pLeft, a_pRight) RTASN1CONTEXTTAG_COMPARE_PRESENT_RETURN_INTERNAL(a_iDiff, a_pLeft, a_pRight, 3)
1388#define RTASN1CONTEXTTAG4_COMPARE_PRESENT_RETURN(a_iDiff, a_pLeft, a_pRight) RTASN1CONTEXTTAG_COMPARE_PRESENT_RETURN_INTERNAL(a_iDiff, a_pLeft, a_pRight, 4)
1389#define RTASN1CONTEXTTAG5_COMPARE_PRESENT_RETURN(a_iDiff, a_pLeft, a_pRight) RTASN1CONTEXTTAG_COMPARE_PRESENT_RETURN_INTERNAL(a_iDiff, a_pLeft, a_pRight, 5)
1390#define RTASN1CONTEXTTAG6_COMPARE_PRESENT_RETURN(a_iDiff, a_pLeft, a_pRight) RTASN1CONTEXTTAG_COMPARE_PRESENT_RETURN_INTERNAL(a_iDiff, a_pLeft, a_pRight, 6)
1391#define RTASN1CONTEXTTAG7_COMPARE_PRESENT_RETURN(a_iDiff, a_pLeft, a_pRight) RTASN1CONTEXTTAG_COMPARE_PRESENT_RETURN_INTERNAL(a_iDiff, a_pLeft, a_pRight, 7)
1392/** @} */
1393
1394
1395/**
1396 * Type information for dynamically bits (see RTASN1DYNTYPE).
1397 */
1398typedef enum RTASN1TYPE
1399{
1400 /** Not present. */
1401 RTASN1TYPE_NOT_PRESENT = 0,
1402 /** Generic ASN.1 for unknown tag/class. */
1403 RTASN1TYPE_CORE,
1404 /** ASN.1 NULL. */
1405 RTASN1TYPE_NULL,
1406 /** ASN.1 integer. */
1407 RTASN1TYPE_INTEGER,
1408 /** ASN.1 boolean. */
1409 RTASN1TYPE_BOOLEAN,
1410 /** ASN.1 character string. */
1411 RTASN1TYPE_STRING,
1412 /** ASN.1 octet string. */
1413 RTASN1TYPE_OCTET_STRING,
1414 /** ASN.1 bite string. */
1415 RTASN1TYPE_BIT_STRING,
1416 /** ASN.1 UTC or Generalize time. */
1417 RTASN1TYPE_TIME,
1418#if 0
1419 /** ASN.1 sequence core. */
1420 RTASN1TYPE_SEQUENCE_CORE,
1421 /** ASN.1 set core. */
1422 RTASN1TYPE_SET_CORE,
1423#endif
1424 /** ASN.1 object identifier. */
1425 RTASN1TYPE_OBJID,
1426 /** End of valid types. */
1427 RTASN1TYPE_END,
1428 /** Type size hack. */
1429 RTASN1TYPE_32BIT_HACK = 0x7fffffff
1430} RTASN1TYPE;
1431
1432
1433/**
1434 * ASN.1 dynamic type record.
1435 */
1436typedef struct RTASN1DYNTYPE
1437{
1438 /** Alternative interpretation provided by a user.
1439 * Before destroying this object, the user must explicitly free this and set
1440 * it to NULL, otherwise there will be memory leaks. */
1441 PRTASN1CORE pUser;
1442 /** The type of data we've got here. */
1443 RTASN1TYPE enmType;
1444 /** Union with data of the type dictated by enmType. */
1445 union
1446 {
1447 /** RTASN1TYPE_CORE. */
1448 RTASN1CORE Core;
1449 /** RTASN1TYPE_NULL. */
1450 RTASN1NULL Asn1Null;
1451 /** RTASN1TYPE_INTEGER. */
1452 RTASN1INTEGER Integer;
1453 /** RTASN1TYPE_BOOLEAN. */
1454 RTASN1BOOLEAN Boolean;
1455 /** RTASN1TYPE_STRING. */
1456 RTASN1STRING String;
1457 /** RTASN1TYPE_OCTET_STRING. */
1458 RTASN1OCTETSTRING OctetString;
1459 /** RTASN1TYPE_BIT_STRING. */
1460 RTASN1BITSTRING BitString;
1461 /** RTASN1TYPE_TIME. */
1462 RTASN1TIME Time;
1463#if 0
1464 /** RTASN1TYPE_SEQUENCE_CORE. */
1465 RTASN1SEQUENCECORE SeqCore;
1466 /** RTASN1TYPE_SET_CORE. */
1467 RTASN1SETCORE SetCore;
1468#endif
1469 /** RTASN1TYPE_OBJID. */
1470 RTASN1OBJID ObjId;
1471 } u;
1472} RTASN1DYNTYPE;
1473/** Pointer to an ASN.1 dynamic type record. */
1474typedef RTASN1DYNTYPE *PRTASN1DYNTYPE;
1475/** Pointer to a const ASN.1 dynamic type record. */
1476typedef RTASN1DYNTYPE const *PCRTASN1DYNTYPE;
1477RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1DYNTYPE, RTDECL, RTAsn1DynType, u.Core);
1478
1479
1480/** @name Virtual Method Table Based API
1481 * @{ */
1482/**
1483 * Calls the destructor of the ASN.1 object.
1484 *
1485 * @param pThisCore The IPRT representation of an ASN.1 object.
1486 */
1487RTDECL(void) RTAsn1VtDelete(PRTASN1CORE pThisCore);
1488
1489/**
1490 * Deep enumeration of all descendants.
1491 *
1492 * @returns IPRT status code, any non VINF_SUCCESS value stems from pfnCallback.
1493 * @param pThisCore Pointer to the ASN.1 core to enumerate members of.
1494 * @param pfnCallback The callback.
1495 * @param uDepth The depth of this object. Children are at +1.
1496 * @param pvUser Callback user argument.
1497 * @param fDepthFirst When set, recurse into child objects before calling
1498 * pfnCallback on then. When clear, the child object
1499 * is first
1500 */
1501RTDECL(int) RTAsn1VtDeepEnum(PRTASN1CORE pThisCore, bool fDepthFirst, uint32_t uDepth,
1502 PFNRTASN1ENUMCALLBACK pfnCallback, void *pvUser);
1503
1504/**
1505 * Clones @a pSrcCore onto @a pThisCore.
1506 *
1507 * The caller must be sure that @a pSrcCore and @a pThisCore are of the same
1508 * types.
1509 *
1510 * @returns IPRT status code.
1511 * @param pThisCore Pointer to the ASN.1 core to clone onto. This shall
1512 * be uninitialized.
1513 * @param pSrcCore Pointer to the ASN.1 core to clone.
1514 * @param pAllocator The allocator to use.
1515 */
1516RTDECL(int) RTAsn1VtClone(PRTASN1CORE pThisCore, PRTASN1CORE pSrcCore, PCRTASN1ALLOCATORVTABLE pAllocator);
1517
1518/**
1519 * Compares two objects.
1520 *
1521 * @returns 0 if equal, -1 if @a pLeft is smaller, 1 if @a pLeft is larger.
1522 * @param pLeftCore Pointer to the ASN.1 core of the left side object.
1523 * @param pRightCore Pointer to the ASN.1 core of the right side object.
1524 */
1525RTDECL(int) RTAsn1VtCompare(PCRTASN1CORE pLeftCore, PCRTASN1CORE pRightCore);
1526
1527/**
1528 * Check sanity.
1529 *
1530 * A primary criteria is that the object is present and initialized.
1531 *
1532 * @returns IPRT status code.
1533 * @param pThisCore Pointer to the ASN.1 core of the object to check out.
1534 * @param fFlags See RTASN1_CHECK_SANITY_F_XXX.
1535 * @param pErrInfo Where to return additional error details. Optional.
1536 * @param pszErrorTag Tag for the additional error details.
1537 */
1538RTDECL(int) RTAsn1VtCheckSanity(PCRTASN1CORE pThisCore, uint32_t fFlags,
1539 PRTERRINFO pErrInfo, const char *pszErrorTag);
1540/** @} */
1541
1542
1543/** @defgroup rp_asn1_encode RTAsn1Encode - ASN.1 Encoding
1544 * @{ */
1545
1546/** @name RTASN1ENCODE_F_XXX
1547 * @{ */
1548/** Use distinguished encoding rules (DER) to encode the object. */
1549#define RTASN1ENCODE_F_DER UINT32_C(0x00000001)
1550/** Use base encoding rules (BER) to encode the object.
1551 * This is currently the same as DER for practical reasons. */
1552#define RTASN1ENCODE_F_BER RTASN1ENCODE_F_DER
1553/** Mask of valid encoding rules. */
1554#define RTASN1ENCODE_F_RULE_MASK UINT32_C(0x00000007)
1555/** @} */
1556
1557
1558/**
1559 * Recalculates cbHdr of and ASN.1 object.
1560 *
1561 * @returns IPRT status code.
1562 * @retval VINF_ASN1_NOT_ENCODED if the header size is zero (default value,
1563 * whatever).
1564 * @param pAsn1Core The object in question.
1565 * @param fFlags Valid combination of the RTASN1ENCODE_F_XXX
1566 * flags. Must include the encoding type.
1567 * @param pErrInfo Extended error info. Optional.
1568 */
1569RTDECL(int) RTAsn1EncodeRecalcHdrSize(PRTASN1CORE pAsn1Core, uint32_t fFlags, PRTERRINFO pErrInfo);
1570
1571/**
1572 * Prepares the ASN.1 structure for encoding.
1573 *
1574 * The preparations is mainly calculating accurate object size, but may also
1575 * involve operations like recoding internal UTF-8 strings to the actual ASN.1
1576 * format and other things that may require memory to allocated/reallocated.
1577 *
1578 * @returns IPRT status code
1579 * @param pRoot The root of the ASN.1 object tree to encode.
1580 * @param fFlags Valid combination of the RTASN1ENCODE_F_XXX
1581 * flags. Must include the encoding type.
1582 * @param pcbEncoded Where to return the encoded size. Optional.
1583 * @param pErrInfo Where to store extended error information.
1584 * Optional.
1585 */
1586RTDECL(int) RTAsn1EncodePrepare(PRTASN1CORE pRoot, uint32_t fFlags, uint32_t *pcbEncoded, PRTERRINFO pErrInfo);
1587
1588/**
1589 * Encodes and writes the header of an ASN.1 object.
1590 *
1591 * @returns IPRT status code.
1592 * @retval VINF_ASN1_NOT_ENCODED if nothing was written (default value,
1593 * whatever).
1594 * @param pAsn1Core The object in question.
1595 * @param fFlags Valid combination of the RTASN1ENCODE_F_XXX
1596 * flags. Must include the encoding type.
1597 * @param pfnWriter The output writer callback.
1598 * @param pvUser The user argument to pass to @a pfnWriter.
1599 * @param pErrInfo Where to store extended error information.
1600 * Optional.
1601 */
1602RTDECL(int) RTAsn1EncodeWriteHeader(PCRTASN1CORE pAsn1Core, uint32_t fFlags, FNRTASN1ENCODEWRITER pfnWriter, void *pvUser,
1603 PRTERRINFO pErrInfo);
1604
1605/**
1606 * Encodes and writes an ASN.1 object.
1607 *
1608 * @returns IPRT status code
1609 * @param pRoot The root of the ASN.1 object tree to encode.
1610 * @param fFlags Valid combination of the RTASN1ENCODE_F_XXX
1611 * flags. Must include the encoding type.
1612 * @param pfnWriter The output writer callback.
1613 * @param pvUser The user argument to pass to @a pfnWriter.
1614 * @param pErrInfo Where to store extended error information.
1615 * Optional.
1616 */
1617RTDECL(int) RTAsn1EncodeWrite(PCRTASN1CORE pRoot, uint32_t fFlags, FNRTASN1ENCODEWRITER pfnWriter, void *pvUser,
1618 PRTERRINFO pErrInfo);
1619
1620/**
1621 * Encodes and writes an ASN.1 object into a caller allocated memory buffer.
1622 *
1623 * @returns IPRT status code
1624 * @param pRoot The root of the ASN.1 object tree to encode.
1625 * @param fFlags Valid combination of the RTASN1ENCODE_F_XXX
1626 * flags. Must include the encoding type.
1627 * @param pvBuf The output buffer.
1628 * @param cbBuf The buffer size. This should have the size
1629 * returned by RTAsn1EncodePrepare().
1630 * @param pErrInfo Where to store extended error information.
1631 * Optional.
1632 */
1633RTDECL(int) RTAsn1EncodeToBuffer(PCRTASN1CORE pRoot, uint32_t fFlags, void *pvBuf, size_t cbBuf, PRTERRINFO pErrInfo);
1634
1635/**
1636 * Helper for when DER encoded ASN.1 is needed for something.
1637 *
1638 * Handy when interfacing with OpenSSL and the many d2i_Xxxxx OpenSSL functions,
1639 * but also handy when structures needs to be digested or similar during signing
1640 * or verification.
1641 *
1642 * We sometimes can use the data we've decoded directly, but often we have
1643 * encode it into a temporary heap buffer.
1644 *
1645 * @returns IPRT status code, details in @a pErrInfo if present.
1646 * @param pRoot The ASN.1 root of the structure to be passed to OpenSSL.
1647 * @param ppbRaw Where to return the pointer to raw encoded data.
1648 * @param pcbRaw Where to return the size of the raw encoded data.
1649 * @param ppvFree Where to return what to pass to RTMemTmpFree, i.e. NULL
1650 * if we use the previously decoded data directly and
1651 * non-NULL if we had to allocate heap and encode it.
1652 * @param pErrInfo Where to return details about encoding issues. Optional.
1653 */
1654RTDECL(int) RTAsn1EncodeQueryRawBits(PRTASN1CORE pRoot, const uint8_t **ppbRaw, uint32_t *pcbRaw,
1655 void **ppvFree, PRTERRINFO pErrInfo);
1656
1657/** @} */
1658
1659
1660
1661/** @defgroup rp_asn1_cursor RTAsn1Cursor - BER, DER, and CER cursor
1662 * @{ */
1663
1664/**
1665 * ASN.1 decoder byte cursor.
1666 */
1667typedef struct RTASN1CURSOR
1668{
1669 /** Pointer to the current (next) byte. */
1670 uint8_t const *pbCur;
1671 /** Number of bytes left to decode. */
1672 uint32_t cbLeft;
1673 /** RTASN1CURSOR_FLAGS_XXX. */
1674 uint8_t fFlags;
1675 /** The cursor depth. */
1676 uint8_t cDepth;
1677 /** Two bytes reserved for future tricks. */
1678 uint8_t abReserved[2];
1679 /** Pointer to the primary cursor. */
1680 struct RTASN1CURSORPRIMARY *pPrimary;
1681 /** Pointer to the parent cursor. */
1682 struct RTASN1CURSOR *pUp;
1683 /** The error tag for this cursor level. */
1684 const char *pszErrorTag;
1685} RTASN1CURSOR;
1686
1687/** @name RTASN1CURSOR_FLAGS_XXX - Cursor flags.
1688 * @{ */
1689/** Enforce DER rules. */
1690#define RTASN1CURSOR_FLAGS_DER RT_BIT(1)
1691/** Enforce CER rules. */
1692#define RTASN1CURSOR_FLAGS_CER RT_BIT(2)
1693/** Pending indefinite length encoding. */
1694#define RTASN1CURSOR_FLAGS_INDEFINITE_LENGTH RT_BIT(3)
1695/** @} */
1696
1697
1698typedef struct RTASN1CURSORPRIMARY
1699{
1700 /** The normal cursor bits. */
1701 RTASN1CURSOR Cursor;
1702 /** For error reporting. */
1703 PRTERRINFO pErrInfo;
1704 /** The allocator virtual method table. */
1705 PCRTASN1ALLOCATORVTABLE pAllocator;
1706 /** Pointer to the first byte. Useful for calculating offsets. */
1707 uint8_t const *pbFirst;
1708} RTASN1CURSORPRIMARY;
1709typedef RTASN1CURSORPRIMARY *PRTASN1CURSORPRIMARY;
1710
1711
1712/**
1713 * Initializes a primary cursor.
1714 *
1715 * The primary cursor is special in that it stores information shared with the
1716 * sub-cursors created by methods like RTAsn1CursorGetContextTagNCursor and
1717 * RTAsn1CursorGetSequenceCursor. Even if just sharing a few items at present,
1718 * it still important to save every possible byte since stack space is scarce in
1719 * some of the execution environments.
1720 *
1721 * @returns Pointer to pCursor->Cursor.
1722 * @param pPrimaryCursor The primary cursor structure to initialize.
1723 * @param pvFirst The first byte to decode.
1724 * @param cb The number of bytes to decode.
1725 * @param pErrInfo Where to store error information.
1726 * @param pAllocator The allocator to use.
1727 * @param fFlags RTASN1CURSOR_FLAGS_XXX.
1728 * @param pszErrorTag The primary error tag.
1729 */
1730RTDECL(PRTASN1CURSOR) RTAsn1CursorInitPrimary(PRTASN1CURSORPRIMARY pPrimaryCursor, void const *pvFirst, uint32_t cb,
1731 PRTERRINFO pErrInfo, PCRTASN1ALLOCATORVTABLE pAllocator, uint32_t fFlags,
1732 const char *pszErrorTag);
1733
1734RTDECL(int) RTAsn1CursorInitSub(PRTASN1CURSOR pParent, uint32_t cb, PRTASN1CURSOR pChild, const char *pszErrorTag);
1735
1736/**
1737 * Initialize a sub-cursor for traversing the content of an ASN.1 object.
1738 *
1739 * @returns IPRT status code.
1740 * @param pParent The parent cursor.
1741 * @param pAsn1Core The ASN.1 object which content we should
1742 * traverse with the sub-cursor.
1743 * @param pChild The sub-cursor to initialize.
1744 * @param pszErrorTag The error tag of the sub-cursor.
1745 */
1746RTDECL(int) RTAsn1CursorInitSubFromCore(PRTASN1CURSOR pParent, PRTASN1CORE pAsn1Core,
1747 PRTASN1CURSOR pChild, const char *pszErrorTag);
1748
1749/**
1750 * Initalizes the an allocation structure prior to making an allocation.
1751 *
1752 * To try unify and optimize memory managment for decoding and in-memory
1753 * construction of ASN.1 objects, each allocation has an allocation structure
1754 * associated with it. This stores the allocator and keep statistics for
1755 * optimizing resizable allocations.
1756 *
1757 * @returns Pointer to the allocator info (for call in alloc parameter).
1758 * @param pCursor The cursor.
1759 * @param pAllocation The allocation structure to initialize.
1760 */
1761RTDECL(PRTASN1ALLOCATION) RTAsn1CursorInitAllocation(PRTASN1CURSOR pCursor, PRTASN1ALLOCATION pAllocation);
1762
1763/**
1764 * Initalizes the an array allocation structure prior to making an allocation.
1765 *
1766 * This is a special case of RTAsn1CursorInitAllocation. We store a little bit
1767 * more detail here in order to optimize growing and shrinking of arrays.
1768 *
1769 * @returns Pointer to the allocator info (for call in alloc parameter).
1770 * @param pCursor The cursor.
1771 * @param pAllocation The allocation structure to initialize.
1772 * @param cbEntry The array entry size.
1773 */
1774RTDECL(PRTASN1ARRAYALLOCATION) RTAsn1CursorInitArrayAllocation(PRTASN1CURSOR pCursor, PRTASN1ARRAYALLOCATION pAllocation,
1775 size_t cbEntry);
1776
1777/**
1778 * Wrapper around RTErrInfoSetV.
1779 *
1780 * @returns @a rc
1781 * @param pCursor The cursor.
1782 * @param rc The return code to return.
1783 * @param pszMsg Message format string.
1784 * @param ... Format arguments.
1785 */
1786RTDECL(int) RTAsn1CursorSetInfo(PRTASN1CURSOR pCursor, int rc, const char *pszMsg, ...) RT_IPRT_FORMAT_ATTR(3, 4);
1787
1788/**
1789 * Wrapper around RTErrInfoSetV.
1790 *
1791 * @returns @a rc
1792 * @param pCursor The cursor.
1793 * @param rc The return code to return.
1794 * @param pszMsg Message format string.
1795 * @param va Format arguments.
1796 */
1797RTDECL(int) RTAsn1CursorSetInfoV(PRTASN1CURSOR pCursor, int rc, const char *pszMsg, va_list va) RT_IPRT_FORMAT_ATTR(3, 0);
1798
1799/**
1800 * Checks that we've reached the end of the data for the cursor.
1801 *
1802 * This differs from RTAsn1CursorCheckEnd in that it does not consider the end
1803 * an error and therefore leaves the error buffer alone.
1804 *
1805 * @returns True if end, otherwise false.
1806 * @param pCursor The cursor we're decoding from.
1807 */
1808RTDECL(bool) RTAsn1CursorIsEnd(PRTASN1CURSOR pCursor);
1809
1810/**
1811 * Checks that we've reached the end of the data for the cursor.
1812 *
1813 * @returns IPRT status code.
1814 * @param pCursor The cursor we're decoding from.
1815 */
1816RTDECL(int) RTAsn1CursorCheckEnd(PRTASN1CURSOR pCursor);
1817
1818/**
1819 * Specialization of RTAsn1CursorCheckEnd for handling indefinite length sequences.
1820 *
1821 * Makes sure we've reached the end of the data for the cursor, and in case of a
1822 * an indefinite length sequence it may adjust sequence length and the parent
1823 * cursor.
1824 *
1825 * @returns IPRT status code.
1826 * @param pCursor The cursor we're decoding from.
1827 * @param pSeqCore The sequence core record.
1828 * @sa RTAsn1CursorCheckSetEnd, RTAsn1CursorCheckOctStrEnd,
1829 * RTAsn1CursorCheckEnd
1830 */
1831RTDECL(int) RTAsn1CursorCheckSeqEnd(PRTASN1CURSOR pCursor, PRTASN1SEQUENCECORE pSeqCore);
1832
1833/**
1834 * Specialization of RTAsn1CursorCheckEnd for handling indefinite length sets.
1835 *
1836 * Makes sure we've reached the end of the data for the cursor, and in case of a
1837 * an indefinite length sets it may adjust set length and the parent cursor.
1838 *
1839 * @returns IPRT status code.
1840 * @param pCursor The cursor we're decoding from.
1841 * @param pSetCore The set core record.
1842 * @sa RTAsn1CursorCheckSeqEnd, RTAsn1CursorCheckOctStrEnd,
1843 * RTAsn1CursorCheckEnd
1844 */
1845RTDECL(int) RTAsn1CursorCheckSetEnd(PRTASN1CURSOR pCursor, PRTASN1SETCORE pSetCore);
1846
1847/**
1848 * Specialization of RTAsn1CursorCheckEnd for handling indefinite length
1849 * constructed octet strings.
1850 *
1851 * This function must used when parsing the content of an octet string, like
1852 * for example the Content of a PKCS\#7 ContentInfo structure. It makes sure
1853 * we've reached the end of the data for the cursor, and in case of a an
1854 * indefinite length sets it may adjust set length and the parent cursor.
1855 *
1856 * @returns IPRT status code.
1857 * @param pCursor The cursor we're decoding from.
1858 * @param pOctetString The octet string.
1859 * @sa RTAsn1CursorCheckSeqEnd, RTAsn1CursorCheckSetEnd,
1860 * RTAsn1CursorCheckEnd
1861 */
1862RTDECL(int) RTAsn1CursorCheckOctStrEnd(PRTASN1CURSOR pCursor, PRTASN1OCTETSTRING pOctetString);
1863
1864
1865/**
1866 * Skips a given number of bytes.
1867 *
1868 * @returns @a pCursor
1869 * @param pCursor The cursor.
1870 * @param cb The number of bytes to skip.
1871 * @internal
1872 */
1873DECLINLINE(PRTASN1CURSOR) RTAsn1CursorSkip(PRTASN1CURSOR pCursor, uint32_t cb)
1874{
1875 if (cb <= pCursor->cbLeft)
1876 {
1877 pCursor->cbLeft -= cb;
1878 pCursor->pbCur += cb;
1879 }
1880 else
1881 {
1882 pCursor->pbCur += pCursor->cbLeft;
1883 pCursor->cbLeft = 0;
1884 }
1885
1886 return pCursor;
1887}
1888
1889/**
1890 * Low-level function for reading an ASN.1 header.
1891 *
1892 * @returns IPRT status code.
1893 * @param pCursor The cursor we're decoding from.
1894 * @param pAsn1Core The output object core.
1895 * @param pszErrorTag Error tag.
1896 * @internal
1897 */
1898RTDECL(int) RTAsn1CursorReadHdr(PRTASN1CURSOR pCursor, PRTASN1CORE pAsn1Core, const char *pszErrorTag);
1899
1900/**
1901 * Common helper for simple tag matching.
1902 *
1903 * @returns IPRT status code.
1904 * @param pCursor The cursor (for error reporting).
1905 * @param pAsn1Core The ASN.1 core structure.
1906 * @param uTag The expected tag.
1907 * @param fClass The expected class.
1908 * @param fString Set if it's a string type that shall follow
1909 * special CER and DER rules wrt to constructed and
1910 * primitive encoding.
1911 * @param fFlags The RTASN1CURSOR_GET_F_XXX flags.
1912 * @param pszErrorTag The error tag.
1913 * @param pszWhat The type/whatever name.
1914 */
1915RTDECL(int) RTAsn1CursorMatchTagClassFlagsEx(PRTASN1CURSOR pCursor, PRTASN1CORE pAsn1Core, uint32_t uTag, uint32_t fClass,
1916 bool fString, uint32_t fFlags, const char *pszErrorTag, const char *pszWhat);
1917
1918/**
1919 * Common helper for simple tag matching.
1920 *
1921 * @returns IPRT status code.
1922 * @param pCursor The cursor (for error reporting).
1923 * @param pAsn1Core The ASN.1 core structure.
1924 * @param uTag The expected tag.
1925 * @param fClass The expected class.
1926 * @param fFlags The RTASN1CURSOR_GET_F_XXX flags.
1927 * @param pszErrorTag The error tag.
1928 * @param pszWhat The type/whatever name.
1929 * @internal
1930 */
1931DECLINLINE(int) RTAsn1CursorMatchTagClassFlags(PRTASN1CURSOR pCursor, PRTASN1CORE pAsn1Core, uint32_t uTag, uint32_t fClass,
1932 uint32_t fFlags, const char *pszErrorTag, const char *pszWhat)
1933{
1934 if (pAsn1Core->uTag == uTag && pAsn1Core->fClass == fClass)
1935 return VINF_SUCCESS;
1936 return RTAsn1CursorMatchTagClassFlagsEx(pCursor, pAsn1Core, uTag, fClass, false /*fString*/, fFlags, pszErrorTag, pszWhat);
1937}
1938
1939
1940/**
1941 * Common helper for simple tag matching for strings.
1942 *
1943 * Check string encoding considerations.
1944 *
1945 * @returns IPRT status code.
1946 * @param pCursor The cursor (for error reporting).
1947 * @param pAsn1Core The ASN.1 core structure.
1948 * @param uTag The expected tag.
1949 * @param fClass The expected class.
1950 * @param fFlags The RTASN1CURSOR_GET_F_XXX flags.
1951 * @param pszErrorTag The error tag.
1952 * @param pszWhat The type/whatever name.
1953 * @internal
1954 */
1955DECLINLINE(int) RTAsn1CursorMatchTagClassFlagsString(PRTASN1CURSOR pCursor, PRTASN1CORE pAsn1Core, uint32_t uTag, uint32_t fClass,
1956 uint32_t fFlags, const char *pszErrorTag, const char *pszWhat)
1957{
1958 if (pAsn1Core->uTag == uTag && pAsn1Core->fClass == fClass)
1959 return VINF_SUCCESS;
1960 return RTAsn1CursorMatchTagClassFlagsEx(pCursor, pAsn1Core, uTag, fClass, true /*fString*/, fFlags, pszErrorTag, pszWhat);
1961}
1962
1963
1964
1965/** @name RTASN1CURSOR_GET_F_XXX - Common flags for all the getters.
1966 * @{ */
1967/** Used for decoding objects with implicit tags assigned to them. This only
1968 * works when calling getters with a unambigious types. */
1969#define RTASN1CURSOR_GET_F_IMPLICIT RT_BIT_32(0)
1970/** @} */
1971
1972/**
1973 * Read ANY object.
1974 *
1975 * @returns IPRT status code.
1976 * @param pCursor The cursor we're decoding from.
1977 * @param fFlags RTASN1CURSOR_GET_F_XXX.
1978 * @param pAsn1Core The output object core.
1979 * @param pszErrorTag Error tag.
1980 */
1981RTDECL(int) RTAsn1CursorGetCore(PRTASN1CURSOR pCursor, uint32_t fFlags, PRTASN1CORE pAsn1Core, const char *pszErrorTag);
1982
1983/**
1984 * Read a NULL object.
1985 *
1986 * @returns IPRT status code.
1987 * @param pCursor The cursor we're decoding from.
1988 * @param fFlags RTASN1CURSOR_GET_F_XXX.
1989 * @param pNull The output NULL object.
1990 * @param pszErrorTag Error tag.
1991 */
1992RTDECL(int) RTAsn1CursorGetNull(PRTASN1CURSOR pCursor, uint32_t fFlags, PRTASN1NULL pNull, const char *pszErrorTag);
1993
1994/**
1995 * Read an INTEGER object.
1996 *
1997 * @returns IPRT status code.
1998 * @param pCursor The cursor we're decoding from.
1999 * @param fFlags RTASN1CURSOR_GET_F_XXX.
2000 * @param pInteger The output integer object.
2001 * @param pszErrorTag Error tag.
2002 */
2003RTDECL(int) RTAsn1CursorGetInteger(PRTASN1CURSOR pCursor, uint32_t fFlags, PRTASN1INTEGER pInteger, const char *pszErrorTag);
2004
2005/**
2006 * Read an BOOLEAN object.
2007 *
2008 * @returns IPRT status code.
2009 * @param pCursor The cursor we're decoding from.
2010 * @param fFlags RTASN1CURSOR_GET_F_XXX.
2011 * @param pBoolean The output boolean object.
2012 * @param pszErrorTag Error tag.
2013 */
2014RTDECL(int) RTAsn1CursorGetBoolean(PRTASN1CURSOR pCursor, uint32_t fFlags, PRTASN1BOOLEAN pBoolean, const char *pszErrorTag);
2015
2016/**
2017 * Retrives an object identifier (aka ObjId or OID) item from the ASN.1 stream.
2018 *
2019 * @returns IPRT status code.
2020 * @param pCursor The cursor.
2021 * @param fFlags RTASN1CURSOR_GET_F_XXX.
2022 * @param pObjId The output ODI object.
2023 * @param pszErrorTag Error tag.
2024 */
2025RTDECL(int) RTAsn1CursorGetObjId(PRTASN1CURSOR pCursor, uint32_t fFlags, PRTASN1OBJID pObjId, const char *pszErrorTag);
2026
2027/**
2028 * Retrives and verifies an object identifier.
2029 *
2030 * @returns IPRT status code.
2031 * @param pCursor The cursor.
2032 * @param fFlags RTASN1CURSOR_GET_F_XXX.
2033 * @param pObjId Where to return the parsed object ID, optional.
2034 * @param pszExpectedObjId The expected object identifier (dotted).
2035 * @param pszErrorTag Error tag.
2036 */
2037RTDECL(int) RTAsn1CursorGetAndCheckObjId(PRTASN1CURSOR pCursor, uint32_t fFlags, PRTASN1OBJID pObjId,
2038 const char *pszExpectedObjId, const char *pszErrorTag);
2039
2040/**
2041 * Read an UTC TIME or GENERALIZED TIME object.
2042 *
2043 * @returns IPRT status code.
2044 * @param pCursor The cursor we're decoding from.
2045 * @param fFlags RTASN1CURSOR_GET_F_XXX.
2046 * @param pTime The output time object.
2047 * @param pszErrorTag Error tag.
2048 */
2049RTDECL(int) RTAsn1CursorGetTime(PRTASN1CURSOR pCursor, uint32_t fFlags, PRTASN1TIME pTime, const char *pszErrorTag);
2050
2051/**
2052 * Read an BIT STRING object (skips past the content).
2053 *
2054 * @returns IPRT status ocde.
2055 * @param pCursor The cursor.
2056 * @param fFlags RTASN1CURSOR_GET_F_XXX.
2057 * @param pBitString The output bit string object.
2058 * @param pszErrorTag Error tag.
2059 */
2060RTDECL(int) RTAsn1CursorGetBitString(PRTASN1CURSOR pCursor, uint32_t fFlags, PRTASN1BITSTRING pBitString,
2061 const char *pszErrorTag);
2062
2063/**
2064 * Read an BIT STRING object (skips past the content), extended version with
2065 * cMaxBits.
2066 *
2067 * @returns IPRT status ocde.
2068 * @param pCursor The cursor.
2069 * @param fFlags RTASN1CURSOR_GET_F_XXX.
2070 * @param cMaxBits The max length of the bit string in bits. Pass
2071 * UINT32_MAX if variable size.
2072 * @param pBitString The output bit string object.
2073 * @param pszErrorTag Error tag.
2074 */
2075RTDECL(int) RTAsn1CursorGetBitStringEx(PRTASN1CURSOR pCursor, uint32_t fFlags, uint32_t cMaxBits, PRTASN1BITSTRING pBitString,
2076 const char *pszErrorTag);
2077
2078/**
2079 * Read an OCTET STRING object (skips past the content).
2080 *
2081 * @returns IPRT status ocde.
2082 * @param pCursor The cursor.
2083 * @param fFlags RTASN1CURSOR_GET_F_XXX.
2084 * @param pOctetString The output octet string object.
2085 * @param pszErrorTag Error tag.
2086 */
2087RTDECL(int) RTAsn1CursorGetOctetString(PRTASN1CURSOR pCursor, uint32_t fFlags, PRTASN1OCTETSTRING pOctetString,
2088 const char *pszErrorTag);
2089
2090/**
2091 * Read any kind of string object, except 'character string (29)'.
2092 *
2093 * @returns IPRT status code.
2094 * @param pCursor The cursor we're decoding from.
2095 * @param fFlags RTASN1CURSOR_GET_F_XXX.
2096 * @param pString The output boolean object.
2097 * @param pszErrorTag Error tag.
2098 */
2099RTDECL(int) RTAsn1CursorGetString(PRTASN1CURSOR pCursor, uint32_t fFlags, PRTASN1STRING pString, const char *pszErrorTag);
2100
2101/**
2102 * Read a IA5 STRING object.
2103 *
2104 * @returns IPRT status code.
2105 * @param pCursor The cursor we're decoding from.
2106 * @param fFlags RTASN1CURSOR_GET_F_XXX.
2107 * @param pString The output boolean object.
2108 * @param pszErrorTag Error tag.
2109 */
2110RTDECL(int) RTAsn1CursorGetIa5String(PRTASN1CURSOR pCursor, uint32_t fFlags, PRTASN1STRING pString, const char *pszErrorTag);
2111
2112/**
2113 * Read a UTF8 STRING object.
2114 *
2115 * @returns IPRT status code.
2116 * @param pCursor The cursor we're decoding from.
2117 * @param fFlags RTASN1CURSOR_GET_F_XXX.
2118 * @param pString The output boolean object.
2119 * @param pszErrorTag Error tag.
2120 */
2121RTDECL(int) RTAsn1CursorGetUtf8String(PRTASN1CURSOR pCursor, uint32_t fFlags, PRTASN1STRING pString, const char *pszErrorTag);
2122
2123/**
2124 * Read a BMP STRING (UCS-2) object.
2125 *
2126 * @returns IPRT status code.
2127 * @param pCursor The cursor we're decoding from.
2128 * @param fFlags RTASN1CURSOR_GET_F_XXX.
2129 * @param pString The output boolean object.
2130 * @param pszErrorTag Error tag.
2131 */
2132RTDECL(int) RTAsn1CursorGetBmpString(PRTASN1CURSOR pCursor, uint32_t fFlags, PRTASN1STRING pString, const char *pszErrorTag);
2133
2134/**
2135 * Read a SEQUENCE object and create a cursor for its content.
2136 *
2137 * @returns IPRT status code.
2138 * @param pCursor The cursor we're decoding from.
2139 * @param fFlags RTASN1CURSOR_GET_F_XXX.
2140 * @param pSeqCore The output sequence core object.
2141 * @param pSeqCursor The output cursor for the sequence content.
2142 * @param pszErrorTag Error tag, this will be associated with the
2143 * returned cursor.
2144 */
2145RTDECL(int) RTAsn1CursorGetSequenceCursor(PRTASN1CURSOR pCursor, uint32_t fFlags,
2146 PRTASN1SEQUENCECORE pSeqCore, PRTASN1CURSOR pSeqCursor, const char *pszErrorTag);
2147
2148/**
2149 * Read a SET object and create a cursor for its content.
2150 *
2151 * @returns IPRT status code.
2152 * @param pCursor The cursor we're decoding from.
2153 * @param fFlags RTASN1CURSOR_GET_F_XXX.
2154 * @param pSetCore The output set core object.
2155 * @param pSetCursor The output cursor for the set content.
2156 * @param pszErrorTag Error tag, this will be associated with the
2157 * returned cursor.
2158 */
2159RTDECL(int) RTAsn1CursorGetSetCursor(PRTASN1CURSOR pCursor, uint32_t fFlags,
2160 PRTASN1SETCORE pSetCore, PRTASN1CURSOR pSetCursor, const char *pszErrorTag);
2161
2162/**
2163 * Read a given constructed context tag and create a cursor for its content.
2164 *
2165 * @returns IPRT status code.
2166 * @param pCursor The cursor we're decoding from.
2167 * @param fFlags RTASN1CURSOR_GET_F_XXX.
2168 * @param uExpectedTag The expected tag.
2169 * @param pVtable The vtable for the context tag node (see
2170 * RTASN1TMPL_PASS_XTAG).
2171 * @param pCtxTag The output context tag object.
2172 * @param pCtxTagCursor The output cursor for the context tag content.
2173 * @param pszErrorTag Error tag, this will be associated with the
2174 * returned cursor.
2175 *
2176 * @remarks There are specialized version of this function for each of the
2177 * numbered context tag structures, like for RTASN1CONTEXTTAG0 there is
2178 * RTAsn1CursorGetContextTag0Cursor.
2179 */
2180RTDECL(int) RTAsn1CursorGetContextTagNCursor(PRTASN1CURSOR pCursor, uint32_t fFlags, uint32_t uExpectedTag,
2181 PCRTASN1COREVTABLE pVtable, PRTASN1CONTEXTTAG pCtxTag, PRTASN1CURSOR pCtxTagCursor,
2182 const char *pszErrorTag);
2183
2184/**
2185 * Read a dynamic ASN.1 type.
2186 *
2187 * @returns IPRT status code.
2188 * @param pCursor The cursor we're decoding from.
2189 * @param fFlags RTASN1CURSOR_GET_F_XXX.
2190 * @param pDynType The output context tag object.
2191 * @param pszErrorTag Error tag.
2192 */
2193RTDECL(int) RTAsn1CursorGetDynType(PRTASN1CURSOR pCursor, uint32_t fFlags, PRTASN1DYNTYPE pDynType, const char *pszErrorTag);
2194
2195/**
2196 * Peeks at the next ASN.1 object.
2197 *
2198 * @returns IPRT status code.
2199 * @param pCursor The cursore we're decoding from.
2200 * @param pAsn1Core Where to store the output of the peek.
2201 */
2202RTDECL(int) RTAsn1CursorPeek(PRTASN1CURSOR pCursor, PRTASN1CORE pAsn1Core);
2203
2204/**
2205 * Checks if the next ASN.1 object matches the given tag and class/flags.
2206 *
2207 * @returns @c true on match, @c false on mismatch.
2208 * @param pCursor The cursore we're decoding from.
2209 * @param uTag The tag number to match against.
2210 * @param fClass The tag class and flags to match against.
2211 */
2212RTDECL(bool) RTAsn1CursorIsNextEx(PRTASN1CURSOR pCursor, uint32_t uTag, uint8_t fClass);
2213
2214
2215
2216/** @internal */
2217#define RTASN1CONTEXTTAG_IMPL_CURSOR_INLINES(a_uTag) \
2218 DECLINLINE(int) RT_CONCAT3(RTAsn1CursorGetContextTag,a_uTag,Cursor)(PRTASN1CURSOR pCursor, uint32_t fFlags, \
2219 PCRTASN1COREVTABLE pVtable, \
2220 RT_CONCAT(PRTASN1CONTEXTTAG,a_uTag) pCtxTag, \
2221 PRTASN1CURSOR pCtxTagCursor, const char *pszErrorTag) \
2222 { /* Constructed is automatically implied if you need a cursor to it. */ \
2223 return RTAsn1CursorGetContextTagNCursor(pCursor, fFlags, a_uTag, pVtable, (PRTASN1CONTEXTTAG)pCtxTag, pCtxTagCursor, pszErrorTag); \
2224 } \
2225 DECLINLINE(int) RT_CONCAT3(RTAsn1ContextTag,a_uTag,InitDefault)(RT_CONCAT(PRTASN1CONTEXTTAG,a_uTag) pCtxTag) \
2226 { /* Constructed is automatically implied if you need to init it with a default value. */ \
2227 return RTAsn1Core_InitDefault(&pCtxTag->Asn1Core, a_uTag, ASN1_TAGCLASS_CONTEXT | ASN1_TAGFLAG_CONSTRUCTED); \
2228 } \
2229 DECLINLINE(int) RT_CONCAT3(RTAsn1CursorIsConstructedContextTag,a_uTag,Next)(PRTASN1CURSOR pCursor) \
2230 { \
2231 return RTAsn1CursorIsNextEx(pCursor, a_uTag, ASN1_TAGCLASS_CONTEXT | ASN1_TAGFLAG_CONSTRUCTED); \
2232 } \
2233 DECLINLINE(int) RT_CONCAT3(RTAsn1CursorIsPrimitiveContextTag,a_uTag,Next)(PRTASN1CURSOR pCursor) \
2234 { \
2235 return RTAsn1CursorIsNextEx(pCursor, a_uTag, ASN1_TAGCLASS_CONTEXT | ASN1_TAGFLAG_PRIMITIVE); \
2236 } \
2237 DECLINLINE(int) RT_CONCAT3(RTAsn1CursorIsAnyContextTag,a_uTag,Next)(PRTASN1CURSOR pCursor) \
2238 { \
2239 return RTAsn1CursorIsNextEx(pCursor, a_uTag, ASN1_TAGCLASS_CONTEXT | ASN1_TAGFLAG_CONSTRUCTED) \
2240 || RTAsn1CursorIsNextEx(pCursor, a_uTag, ASN1_TAGCLASS_CONTEXT | ASN1_TAGFLAG_PRIMITIVE);\
2241 } \
2242
2243RTASN1CONTEXTTAG_IMPL_CURSOR_INLINES(0)
2244RTASN1CONTEXTTAG_IMPL_CURSOR_INLINES(1)
2245RTASN1CONTEXTTAG_IMPL_CURSOR_INLINES(2)
2246RTASN1CONTEXTTAG_IMPL_CURSOR_INLINES(3)
2247RTASN1CONTEXTTAG_IMPL_CURSOR_INLINES(4)
2248RTASN1CONTEXTTAG_IMPL_CURSOR_INLINES(5)
2249RTASN1CONTEXTTAG_IMPL_CURSOR_INLINES(6)
2250RTASN1CONTEXTTAG_IMPL_CURSOR_INLINES(7)
2251#undef RTASN1CONTEXTTAG_IMPL_CURSOR_INLINES
2252
2253
2254/**
2255 * Checks if the next object is a boolean.
2256 *
2257 * @returns true / false
2258 * @param pCursor The cursor we're decoding from.
2259 * @remarks May produce error info output on mismatch.
2260 */
2261DECLINLINE(bool) RTAsn1CursorIsBooleanNext(PRTASN1CURSOR pCursor)
2262{
2263 return RTAsn1CursorIsNextEx(pCursor, ASN1_TAG_BOOLEAN, ASN1_TAGFLAG_PRIMITIVE | ASN1_TAGCLASS_UNIVERSAL);
2264}
2265
2266
2267/**
2268 * Checks if the next object is a set.
2269 *
2270 * @returns true / false
2271 * @param pCursor The cursor we're decoding from.
2272 * @remarks May produce error info output on mismatch.
2273 */
2274DECLINLINE(bool) RTAsn1CursorIsSetNext(PRTASN1CURSOR pCursor)
2275{
2276 return RTAsn1CursorIsNextEx(pCursor, ASN1_TAG_SET, ASN1_TAGFLAG_CONSTRUCTED | ASN1_TAGCLASS_UNIVERSAL);
2277}
2278
2279
2280/** @} */
2281
2282
2283/** @name ASN.1 Utility APIs
2284 * @{ */
2285
2286/**
2287 * Dumps an IPRT representation of a ASN.1 object tree.
2288 *
2289 * @returns IPRT status code.
2290 * @param pAsn1Core The ASN.1 object which members should be dumped.
2291 * @param fFlags RTASN1DUMP_F_XXX.
2292 * @param uLevel The indentation level to start at.
2293 * @param pfnPrintfV The output function.
2294 * @param pvUser Argument to the output function.
2295 */
2296RTDECL(int) RTAsn1Dump(PCRTASN1CORE pAsn1Core, uint32_t fFlags, uint32_t uLevel, PFNRTDUMPPRINTFV pfnPrintfV, void *pvUser);
2297
2298/**
2299 * Queries the name for an object identifier.
2300 *
2301 * This API is very simple due to how we store the data.
2302 *
2303 * @returns IPRT status code.
2304 * @retval VINF_SUCCESS on success.
2305 * @retval VERR_NOT_FOUND if not found.
2306 * @retval VERR_BUFFER_OVERFLOW if more buffer space is required.
2307 *
2308 * @param pObjId The object ID to name.
2309 * @param pszDst Where to store the name if found.
2310 * @param cbDst The size of the destination buffer.
2311 */
2312RTDECL(int) RTAsn1QueryObjIdName(PCRTASN1OBJID pObjId, char *pszDst, size_t cbDst);
2313
2314/** @} */
2315
2316/** @} */
2317
2318RT_C_DECLS_END
2319
2320#endif /* !IPRT_INCLUDED_asn1_h */
2321
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette