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 |
|
---|
38 | RT_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. */
|
---|
47 | typedef struct RTASN1ALLOCATION *PRTASN1ALLOCATION;
|
---|
48 | /** Pointer to ASN.1 array allocation information. */
|
---|
49 | typedef struct RTASN1ARRAYALLOCATION *PRTASN1ARRAYALLOCATION;
|
---|
50 | /** Pointer to a ASN.1 byte decoder cursor. */
|
---|
51 | typedef 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 | */
|
---|
61 | typedef 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. */
|
---|
153 | typedef RTASN1ALLOCATORVTABLE *PRTASN1ALLOCATORVTABLE;
|
---|
154 | /** Pointer to a const ASN.1 allocator vtable. */
|
---|
155 | typedef RTASN1ALLOCATORVTABLE const *PCRTASN1ALLOCATORVTABLE;
|
---|
156 |
|
---|
157 | /** The default ASN.1 allocator. */
|
---|
158 | extern RTDATADECL(RTASN1ALLOCATORVTABLE const) g_RTAsn1DefaultAllocator;
|
---|
159 |
|
---|
160 | /** The Electric Fence ASN.1 allocator. */
|
---|
161 | extern RTDATADECL(RTASN1ALLOCATORVTABLE const) g_RTAsn1EFenceAllocator;
|
---|
162 |
|
---|
163 | /** The safer ASN.1 allocator for sensitive data. */
|
---|
164 | extern RTDATADECL(RTASN1ALLOCATORVTABLE const) g_RTAsn1SaferAllocator;
|
---|
165 |
|
---|
166 |
|
---|
167 | /**
|
---|
168 | * Allocation information.
|
---|
169 | */
|
---|
170 | typedef 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 | */
|
---|
189 | typedef 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 | */
|
---|
217 | RTDECL(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 | */
|
---|
229 | RTDECL(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 | */
|
---|
238 | RTDECL(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 | */
|
---|
248 | RTDECL(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 | */
|
---|
259 | RTDECL(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 | */
|
---|
274 | RTDECL(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 | */
|
---|
283 | RTDECL(void) RTAsn1MemFreeArray(PRTASN1ARRAYALLOCATION pAllocation, void **papvArray);
|
---|
284 |
|
---|
285 |
|
---|
286 | /** Pointer to a core ASN.1 encoding info structure. */
|
---|
287 | typedef struct RTASN1CORE *PRTASN1CORE;
|
---|
288 | /** Pointer to a const core ASN.1 encoding info structure. */
|
---|
289 | typedef struct RTASN1CORE const *PCRTASN1CORE;
|
---|
290 |
|
---|
291 | RTDECL(int) RTAsn1ContentAllocZ(struct RTASN1CORE *pAsn1Core, size_t cb, PCRTASN1ALLOCATORVTABLE pAllocator);
|
---|
292 | RTDECL(int) RTAsn1ContentDup(struct RTASN1CORE *pAsn1Core, void const *pvSrc, size_t cbSrc, PCRTASN1ALLOCATORVTABLE pAllocator);
|
---|
293 | RTDECL(int) RTAsn1ContentReallocZ(struct RTASN1CORE *pAsn1Core, size_t cb, PCRTASN1ALLOCATORVTABLE pAllocator);
|
---|
294 | RTDECL(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 | */
|
---|
309 | typedef DECLCALLBACKTYPE(int, FNRTASN1ENUMCALLBACK,(struct RTASN1CORE *pAsn1Core, const char *pszName, uint32_t uDepth,
|
---|
310 | void *pvUser));
|
---|
311 | /** Pointer to an ASN.1 object enumeration callback. */
|
---|
312 | typedef 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 | */
|
---|
323 | typedef DECLCALLBACKTYPE(int, FNRTASN1ENCODEWRITER,(const void *pvBuf, size_t cbToWrite, void *pvUser, PRTERRINFO pErrInfo));
|
---|
324 | /** Pointer to an ASN.1 encoding writer callback. */
|
---|
325 | typedef 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 | */
|
---|
340 | typedef DECLCALLBACKTYPE(void, FNRTASN1COREVTDTOR,(PRTASN1CORE pThisCore));
|
---|
341 | /** Pointer to a FNRTASN1COREVTDTOR method. */
|
---|
342 | typedef 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 | */
|
---|
353 | typedef DECLCALLBACKTYPE(int, FNRTASN1COREVTENUM,(PRTASN1CORE pThisCore, PFNRTASN1ENUMCALLBACK pfnCallback,
|
---|
354 | uint32_t uDepth, void *pvUser));
|
---|
355 | /** Pointer to a FNRTASN1COREVTENUM method. */
|
---|
356 | typedef 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 | */
|
---|
367 | typedef DECLCALLBACKTYPE(int, FNRTASN1COREVTCLONE,(PRTASN1CORE pThisCore, PCRTASN1CORE pSrcCore,
|
---|
368 | PCRTASN1ALLOCATORVTABLE pAllocator));
|
---|
369 | /** Pointer to a FNRTASN1COREVTCLONE method. */
|
---|
370 | typedef 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 | */
|
---|
381 | typedef DECLCALLBACKTYPE(int, FNRTASN1COREVTCOMPARE,(PCRTASN1CORE pLeftCore, PCRTASN1CORE pRightCore));
|
---|
382 | /** Pointer to a FNRTASN1COREVTCOMPARE method. */
|
---|
383 | typedef 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 | */
|
---|
394 | typedef DECLCALLBACKTYPE(int, FNRTASN1COREVTCHECKSANITY,(PCRTASN1CORE pThisCore, uint32_t fFlags,
|
---|
395 | PRTERRINFO pErrInfo, const char *pszErrorTag));
|
---|
396 | /** Pointer to a FNRTASN1COREVTCHECKSANITY method. */
|
---|
397 | typedef 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 | */
|
---|
411 | typedef DECLCALLBACKTYPE(int, FNRTASN1COREVTENCODEPREP,(PRTASN1CORE pThisCore, uint32_t fFlags, PRTERRINFO pErrInfo));
|
---|
412 | /** Pointer to a FNRTASN1COREVTENCODEWRITE method. */
|
---|
413 | typedef 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 | */
|
---|
428 | typedef DECLCALLBACKTYPE(int, FNRTASN1COREVTENCODEWRITE,(PRTASN1CORE pThisCore, uint32_t fFlags, PFNRTASN1ENCODEWRITER pfnWriter,
|
---|
429 | void *pvUser, PRTERRINFO pErrInfo));
|
---|
430 | /** Pointer to a FNRTASN1COREVTENCODEWRITE method. */
|
---|
431 | typedef 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 | */
|
---|
441 | typedef 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. */
|
---|
469 | typedef struct RTASN1COREVTABLE *PRTASN1COREVTABLE;
|
---|
470 | /** Pointer to a const ASN.1 allocator vtable. */
|
---|
471 | typedef 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 | */
|
---|
544 | typedef 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. */
|
---|
574 | extern RTDATADECL(RTASN1COREVTABLE const) g_RTAsn1Core_Vtable;
|
---|
575 |
|
---|
576 | RTASN1TYPE_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 |
|
---|
644 | DECL_FORCE_INLINE(PRTASN1CORE) RTAsn1Core_GetAsn1Core(PCRTASN1CORE pThis)
|
---|
645 | {
|
---|
646 | return (PRTASN1CORE)pThis;
|
---|
647 | }
|
---|
648 |
|
---|
649 |
|
---|
650 | DECL_FORCE_INLINE(bool) RTAsn1Core_IsPresent(PCRTASN1CORE pThis)
|
---|
651 | {
|
---|
652 | return pThis && RTASN1CORE_IS_PRESENT(pThis);
|
---|
653 | }
|
---|
654 |
|
---|
655 |
|
---|
656 | RTDECL(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 | */
|
---|
665 | RTDECL(int) RTAsn1Core_InitDefault(PRTASN1CORE pAsn1Core, uint32_t uTag, uint8_t fClass);
|
---|
666 | RTDECL(int) RTAsn1Core_CloneContent(PRTASN1CORE pThis, PCRTASN1CORE pSrc, PCRTASN1ALLOCATORVTABLE pAllocator);
|
---|
667 | RTDECL(int) RTAsn1Core_CloneNoContent(PRTASN1CORE pThis, PCRTASN1CORE pSrc);
|
---|
668 | RTDECL(int) RTAsn1Core_SetTagAndFlags(PRTASN1CORE pAsn1Core, uint32_t uTag, uint8_t fClass);
|
---|
669 | RTDECL(int) RTAsn1Core_ChangeTag(PRTASN1CORE pAsn1Core, uint32_t uTag);
|
---|
670 | RTDECL(void) RTAsn1Core_ResetImplict(PRTASN1CORE pThis);
|
---|
671 | RTDECL(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 | */
|
---|
680 | typedef struct RTASN1DUMMY
|
---|
681 | {
|
---|
682 | /** Core ASN.1. */
|
---|
683 | RTASN1CORE Asn1Core;
|
---|
684 | } RTASN1DUMMY;
|
---|
685 | /** Pointer to a dummy record. */
|
---|
686 | typedef RTASN1DUMMY *PRTASN1DUMMY;
|
---|
687 |
|
---|
688 |
|
---|
689 | /**
|
---|
690 | * Initalizes a dummy ASN.1 object.
|
---|
691 | *
|
---|
692 | * @returns VINF_SUCCESS.
|
---|
693 | * @param pThis The dummy object.
|
---|
694 | */
|
---|
695 | RTDECL(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 | */
|
---|
704 | DECLINLINE(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 | */
|
---|
714 | typedef struct RTASN1SEQUENCECORE
|
---|
715 | {
|
---|
716 | /** Core ASN.1 encoding details. */
|
---|
717 | RTASN1CORE Asn1Core;
|
---|
718 | } RTASN1SEQUENCECORE;
|
---|
719 | /** Pointer to an ASN.1 sequence core (IPRT representation). */
|
---|
720 | typedef RTASN1SEQUENCECORE *PRTASN1SEQUENCECORE;
|
---|
721 | /** Pointer to a const ASN.1 sequence core (IPRT representation). */
|
---|
722 | typedef RTASN1SEQUENCECORE const *PCRTASN1SEQUENCECORE;
|
---|
723 |
|
---|
724 | RTDECL(int) RTAsn1SequenceCore_Init(PRTASN1SEQUENCECORE pSeqCore, PCRTASN1COREVTABLE pVtable);
|
---|
725 | RTDECL(int) RTAsn1SequenceCore_Clone(PRTASN1SEQUENCECORE pSeqCore, PCRTASN1COREVTABLE pVtable, PCRTASN1SEQUENCECORE pSrc);
|
---|
726 |
|
---|
727 | /**
|
---|
728 | * ASN.1 sequence-of core (IPRT representation).
|
---|
729 | */
|
---|
730 | #if 0
|
---|
731 | typedef 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). */
|
---|
737 | typedef RTASN1SEQUENCECORE *PRTASN1SEQUENCECORE;
|
---|
738 | /** Pointer to a const ASN.1 sequence-of core (IPRT representation). */
|
---|
739 | typedef RTASN1SEQUENCECORE const *PCRTASN1SEQUENCECORE;
|
---|
740 | #else
|
---|
741 | # define RTASN1SEQOFCORE RTASN1SEQUENCECORE
|
---|
742 | # define PRTASN1SEQOFCORE PRTASN1SEQUENCECORE
|
---|
743 | # define PCRTASN1SEQOFCORE PCRTASN1SEQUENCECORE
|
---|
744 | #endif
|
---|
745 | RTDECL(int) RTAsn1SeqOfCore_Init(PRTASN1SEQOFCORE pThis, PCRTASN1COREVTABLE pVtable);
|
---|
746 | RTDECL(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 | */
|
---|
788 | typedef struct RTASN1SETCORE
|
---|
789 | {
|
---|
790 | /** Core ASN.1 encoding details. */
|
---|
791 | RTASN1CORE Asn1Core;
|
---|
792 | } RTASN1SETCORE;
|
---|
793 | /** Pointer to an ASN.1 set core (IPRT representation). */
|
---|
794 | typedef RTASN1SETCORE *PRTASN1SETCORE;
|
---|
795 | /** Pointer to a const ASN.1 set core (IPRT representation). */
|
---|
796 | typedef RTASN1SETCORE const *PCRTASN1SETCORE;
|
---|
797 |
|
---|
798 | RTDECL(int) RTAsn1SetCore_Init(PRTASN1SETCORE pThis, PCRTASN1COREVTABLE pVtable);
|
---|
799 | RTDECL(int) RTAsn1SetCore_Clone(PRTASN1SETCORE pThis, PCRTASN1COREVTABLE pVtable, PCRTASN1SETCORE pSrc);
|
---|
800 |
|
---|
801 | /**
|
---|
802 | * ASN.1 set-of core (IPRT representation).
|
---|
803 | */
|
---|
804 | #if 0
|
---|
805 | typedef 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). */
|
---|
811 | typedef RTASN1SETUENCECORE *PRTASN1SETUENCECORE;
|
---|
812 | /** Pointer to a const ASN.1 set-of core (IPRT representation). */
|
---|
813 | typedef RTASN1SETUENCECORE const *PCRTASN1SETUENCECORE;
|
---|
814 | #else
|
---|
815 | # define RTASN1SETOFCORE RTASN1SETCORE
|
---|
816 | # define PRTASN1SETOFCORE PRTASN1SETCORE
|
---|
817 | # define PCRTASN1SETOFCORE PCRTASN1SETCORE
|
---|
818 | #endif
|
---|
819 | RTDECL(int) RTAsn1SetOfCore_Init(PRTASN1SETOFCORE pThis, PCRTASN1COREVTABLE pVtable);
|
---|
820 | RTDECL(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 | */
|
---|
831 | RTASN1_IMPL_GEN_SEQ_OF_TYPEDEFS_AND_PROTOS(RTASN1SEQOFCORES, RTASN1CORE, RTDECL, RTAsn1SeqOfCores);
|
---|
832 | RTASN1_IMPL_GEN_SET_OF_TYPEDEFS_AND_PROTOS(RTASN1SETOFCORES, RTASN1CORE, RTDECL, RTAsn1SetOfCores);
|
---|
833 |
|
---|
834 |
|
---|
835 | /**
|
---|
836 | * ASN.1 null (IPRT representation).
|
---|
837 | */
|
---|
838 | typedef struct RTASN1NULL
|
---|
839 | {
|
---|
840 | /** Core ASN.1 encoding details. */
|
---|
841 | RTASN1CORE Asn1Core;
|
---|
842 | } RTASN1NULL;
|
---|
843 | /** Pointer to an ASN.1 null (IPRT representation). */
|
---|
844 | typedef RTASN1NULL *PRTASN1NULL;
|
---|
845 | /** Pointer to a const ASN.1 null (IPRT representation). */
|
---|
846 | typedef RTASN1NULL const *PCRTASN1NULL;
|
---|
847 | /** The Vtable for a RTASN1NULL structure. */
|
---|
848 | extern RTDATADECL(RTASN1COREVTABLE const) g_RTAsn1Null_Vtable;
|
---|
849 |
|
---|
850 | RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1NULL, RTDECL, RTAsn1Null, Asn1Core);
|
---|
851 |
|
---|
852 |
|
---|
853 | /**
|
---|
854 | * ASN.1 integer (IPRT representation).
|
---|
855 | */
|
---|
856 | typedef 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). */
|
---|
867 | typedef RTASN1INTEGER *PRTASN1INTEGER;
|
---|
868 | /** Pointer to a const ASN.1 integer (IPRT representation). */
|
---|
869 | typedef RTASN1INTEGER const *PCRTASN1INTEGER;
|
---|
870 | /** The Vtable for a RTASN1INTEGER structure. */
|
---|
871 | extern RTDATADECL(RTASN1COREVTABLE const) g_RTAsn1Integer_Vtable;
|
---|
872 |
|
---|
873 | RTASN1TYPE_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 | */
|
---|
882 | RTDECL(int) RTAsn1Integer_InitDefault(PRTASN1INTEGER pInteger, uint64_t uValue, PCRTASN1ALLOCATORVTABLE pAllocator);
|
---|
883 |
|
---|
884 | RTDECL(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 | */
|
---|
892 | RTDECL(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 | */
|
---|
901 | RTDECL(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 | */
|
---|
911 | RTDECL(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 | */
|
---|
922 | RTDECL(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 | */
|
---|
934 | RTDECL(int) RTAsn1Integer_ToBigNum(PCRTASN1INTEGER pInteger, PRTBIGNUM pBigNum, uint32_t fBigNumInit);
|
---|
935 | RTDECL(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 | */
|
---|
954 | RTDECL(int) RTAsn1Integer_ToString(PRTASN1INTEGER pThis, char *pszBuf, size_t cbBuf, uint32_t fFlags, size_t *pcbActual);
|
---|
955 |
|
---|
956 | RTASN1_IMPL_GEN_SEQ_OF_TYPEDEFS_AND_PROTOS(RTASN1SEQOFINTEGERS, RTASN1INTEGER, RTDECL, RTAsn1SeqOfIntegers);
|
---|
957 | RTASN1_IMPL_GEN_SET_OF_TYPEDEFS_AND_PROTOS(RTASN1SETOFINTEGERS, RTASN1INTEGER, RTDECL, RTAsn1SetOfIntegers);
|
---|
958 |
|
---|
959 |
|
---|
960 |
|
---|
961 | /**
|
---|
962 | * ASN.1 boolean (IPRT representation).
|
---|
963 | */
|
---|
964 | typedef 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. */
|
---|
972 | typedef RTASN1BOOLEAN *PRTASN1BOOLEAN;
|
---|
973 | /** Pointer to the const IPRT representation of an ASN.1 boolean. */
|
---|
974 | typedef RTASN1BOOLEAN const *PCRTASN1BOOLEAN;
|
---|
975 | /** The Vtable for a RTASN1BOOLEAN structure. */
|
---|
976 | extern RTDATADECL(RTASN1COREVTABLE const) g_RTAsn1Boolean_Vtable;
|
---|
977 |
|
---|
978 | RTASN1TYPE_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 | */
|
---|
987 | RTDECL(int) RTAsn1Boolean_InitDefault(PRTASN1BOOLEAN pBoolean, bool fValue, PCRTASN1ALLOCATORVTABLE pAllocator);
|
---|
988 | RTDECL(int) RTAsn1Boolean_Set(PRTASN1BOOLEAN pThis, bool fValue);
|
---|
989 |
|
---|
990 | RTASN1_IMPL_GEN_SEQ_OF_TYPEDEFS_AND_PROTOS(RTASN1SEQOFBOOLEANS, RTASN1BOOLEAN, RTDECL, RTAsn1SeqOfBooleans);
|
---|
991 | RTASN1_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 | */
|
---|
1001 | typedef 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. */
|
---|
1010 | typedef RTASN1TIME *PRTASN1TIME;
|
---|
1011 | /** Pointer to a const IPRT representation of ASN.1 UTC/Generalized time. */
|
---|
1012 | typedef RTASN1TIME const *PCRTASN1TIME;
|
---|
1013 | /** The Vtable for a RTASN1TIME structure. */
|
---|
1014 | extern RTDATADECL(RTASN1COREVTABLE const) g_RTAsn1Time_Vtable;
|
---|
1015 |
|
---|
1016 | RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1TIME, RTDECL, RTAsn1Time, Asn1Core);
|
---|
1017 |
|
---|
1018 | RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1TIME, RTDECL, RTAsn1UtcTime, Asn1Core);
|
---|
1019 | RTASN1TYPE_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 | */
|
---|
1028 | RTDECL(int) RTAsn1Time_CompareWithTimeSpec(PCRTASN1TIME pLeft, PCRTTIMESPEC pTsRight);
|
---|
1029 |
|
---|
1030 | RTDECL(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 |
|
---|
1040 | RTASN1_IMPL_GEN_SEQ_OF_TYPEDEFS_AND_PROTOS(RTASN1SEQOFTIMES, RTASN1TIME, RTDECL, RTAsn1SeqOfTimes);
|
---|
1041 | RTASN1_IMPL_GEN_SET_OF_TYPEDEFS_AND_PROTOS(RTASN1SETOFTIMES, RTASN1TIME, RTDECL, RTAsn1SetOfTimes);
|
---|
1042 |
|
---|
1043 |
|
---|
1044 |
|
---|
1045 | /**
|
---|
1046 | * ASN.1 object identifier (IPRT representation).
|
---|
1047 | */
|
---|
1048 | typedef 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. */
|
---|
1071 | typedef RTASN1OBJID *PRTASN1OBJID;
|
---|
1072 | /** Pointer to a const ASN.1 object identifier representation. */
|
---|
1073 | typedef RTASN1OBJID const *PCRTASN1OBJID;
|
---|
1074 | /** The Vtable for a RTASN1OBJID structure. */
|
---|
1075 | extern RTDATADECL(RTASN1COREVTABLE const) g_RTAsn1ObjId_Vtable;
|
---|
1076 |
|
---|
1077 | RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1OBJID, RTDECL, RTAsn1ObjId, Asn1Core);
|
---|
1078 |
|
---|
1079 | RTDECL(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 | */
|
---|
1088 | RTDECL(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 | */
|
---|
1101 | RTDECL(bool) RTAsn1ObjId_StartsWith(PCRTASN1OBJID pThis, const char *pszStartsWith);
|
---|
1102 |
|
---|
1103 | RTDECL(uint8_t) RTAsn1ObjIdCountComponents(PCRTASN1OBJID pThis);
|
---|
1104 | RTDECL(uint32_t) RTAsn1ObjIdGetComponentsAsUInt32(PCRTASN1OBJID pThis, uint8_t iComponent);
|
---|
1105 | RTDECL(uint32_t) RTAsn1ObjIdGetLastComponentsAsUInt32(PCRTASN1OBJID pThis);
|
---|
1106 |
|
---|
1107 | RTASN1_IMPL_GEN_SEQ_OF_TYPEDEFS_AND_PROTOS(RTASN1SEQOFOBJIDS, RTASN1OBJID, RTDECL, RTAsn1SeqOfObjIds);
|
---|
1108 | RTASN1_IMPL_GEN_SET_OF_TYPEDEFS_AND_PROTOS(RTASN1SETOFOBJIDS, RTASN1OBJID, RTDECL, RTAsn1SetOfObjIds);
|
---|
1109 | RTASN1_IMPL_GEN_SET_OF_TYPEDEFS_AND_PROTOS(RTASN1SETOFOBJIDSEQS, RTASN1SEQOFOBJIDS, RTDECL, RTAsn1SetOfObjIdSeqs);
|
---|
1110 |
|
---|
1111 |
|
---|
1112 | /**
|
---|
1113 | * ASN.1 bit string (IPRT representation).
|
---|
1114 | */
|
---|
1115 | typedef 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. */
|
---|
1134 | typedef RTASN1BITSTRING *PRTASN1BITSTRING;
|
---|
1135 | /** Pointer to the const IPRT representation of an ASN.1 bit string. */
|
---|
1136 | typedef RTASN1BITSTRING const *PCRTASN1BITSTRING;
|
---|
1137 | /** The Vtable for a RTASN1BITSTRING structure. */
|
---|
1138 | extern RTDATADECL(RTASN1COREVTABLE const) g_RTAsn1BitString_Vtable;
|
---|
1139 |
|
---|
1140 | RTASN1TYPE_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 |
|
---|
1158 | RTDECL(int) RTAsn1BitString_DecodeAsn1Ex(PRTASN1CURSOR pCursor, uint32_t fFlags, uint32_t cMaxBits, PRTASN1BITSTRING pThis,
|
---|
1159 | const char *pszErrorTag);
|
---|
1160 | RTDECL(uint64_t) RTAsn1BitString_GetAsUInt64(PCRTASN1BITSTRING pThis);
|
---|
1161 | RTDECL(int) RTAsn1BitString_RefreshContent(PRTASN1BITSTRING pThis, uint32_t fFlags,
|
---|
1162 | PCRTASN1ALLOCATORVTABLE pAllocator, PRTERRINFO pErrInfo);
|
---|
1163 | RTDECL(bool) RTAsn1BitString_AreContentBitsValid(PCRTASN1BITSTRING pThis, uint32_t fFlags);
|
---|
1164 |
|
---|
1165 | RTASN1_IMPL_GEN_SEQ_OF_TYPEDEFS_AND_PROTOS(RTASN1SEQOFBITSTRINGS, RTASN1BITSTRING, RTDECL, RTAsn1SeqOfBitStrings);
|
---|
1166 | RTASN1_IMPL_GEN_SET_OF_TYPEDEFS_AND_PROTOS(RTASN1SETOFBITSTRINGS, RTASN1BITSTRING, RTDECL, RTAsn1SetOfBitStrings);
|
---|
1167 |
|
---|
1168 |
|
---|
1169 | /**
|
---|
1170 | * ASN.1 octet string (IPRT representation).
|
---|
1171 | */
|
---|
1172 | typedef 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. */
|
---|
1187 | typedef RTASN1OCTETSTRING *PRTASN1OCTETSTRING;
|
---|
1188 | /** Pointer to the const IPRT representation of an ASN.1 octet string. */
|
---|
1189 | typedef RTASN1OCTETSTRING const *PCRTASN1OCTETSTRING;
|
---|
1190 | /** The Vtable for a RTASN1OCTETSTRING structure. */
|
---|
1191 | extern RTDATADECL(RTASN1COREVTABLE const) g_RTAsn1OctetString_Vtable;
|
---|
1192 |
|
---|
1193 | RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1OCTETSTRING, RTDECL, RTAsn1OctetString, Asn1Core);
|
---|
1194 |
|
---|
1195 | RTDECL(bool) RTAsn1OctetString_AreContentBytesValid(PCRTASN1OCTETSTRING pThis, uint32_t fFlags);
|
---|
1196 | RTDECL(int) RTAsn1OctetString_RefreshContent(PRTASN1OCTETSTRING pThis, uint32_t fFlags,
|
---|
1197 | PCRTASN1ALLOCATORVTABLE pAllocator, PRTERRINFO pErrInfo);
|
---|
1198 |
|
---|
1199 | RTASN1_IMPL_GEN_SEQ_OF_TYPEDEFS_AND_PROTOS(RTASN1SEQOFOCTETSTRINGS, RTASN1OCTETSTRING, RTDECL, RTAsn1SeqOfOctetStrings);
|
---|
1200 | RTASN1_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 | */
|
---|
1207 | typedef 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. */
|
---|
1220 | typedef RTASN1STRING *PRTASN1STRING;
|
---|
1221 | /** Pointer to the const IPRT representation of an ASN.1 string. */
|
---|
1222 | typedef RTASN1STRING const *PCRTASN1STRING;
|
---|
1223 | /** The Vtable for a RTASN1STRING structure. */
|
---|
1224 | extern RTDATADECL(RTASN1COREVTABLE const) g_RTAsn1String_Vtable;
|
---|
1225 |
|
---|
1226 | RTASN1TYPE_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 |
|
---|
1246 | RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1NumericString, Asn1Core);
|
---|
1247 | RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1PrintableString, Asn1Core);
|
---|
1248 | RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1T61String, Asn1Core);
|
---|
1249 | RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1VideoTexString, Asn1Core);
|
---|
1250 | RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1VisibleString, Asn1Core);
|
---|
1251 | RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1Ia5String, Asn1Core);
|
---|
1252 | RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1GraphicString, Asn1Core);
|
---|
1253 | RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1GeneralString, Asn1Core);
|
---|
1254 | RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1Utf8String, Asn1Core);
|
---|
1255 | RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1BmpString, Asn1Core);
|
---|
1256 | RTASN1TYPE_STANDARD_PROTOTYPES(RTASN1STRING, RTDECL, RTAsn1UniversalString, Asn1Core);
|
---|
1257 |
|
---|
1258 | RTDECL(int) RTAsn1String_InitWithValue(PRTASN1STRING pThis, const char *pszUtf8Value, PCRTASN1ALLOCATORVTABLE pAllocator);
|
---|
1259 | RTDECL(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 | */
|
---|
1271 | RTDECL(int) RTAsn1String_CompareEx(PCRTASN1STRING pLeft, PCRTASN1STRING pRight, bool fTypeToo);
|
---|
1272 | RTDECL(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 | */
|
---|
1282 | RTDECL(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 | */
|
---|
1294 | RTDECL(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 | */
|
---|
1312 | RTDECL(int) RTAsn1String_QueryUtf8(PCRTASN1STRING pString, const char **ppsz, size_t *pcch);
|
---|
1313 | RTDECL(int) RTAsn1String_RecodeAsUtf8(PRTASN1STRING pThis, PCRTASN1ALLOCATORVTABLE pAllocator);
|
---|
1314 |
|
---|
1315 | RTASN1_IMPL_GEN_SEQ_OF_TYPEDEFS_AND_PROTOS(RTASN1SEQOFSTRINGS, RTASN1STRING, RTDECL, RTAsn1SeqOfStrings);
|
---|
1316 | RTASN1_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 | */
|
---|
1330 | typedef struct RTASN1CONTEXTTAG
|
---|
1331 | {
|
---|
1332 | /** Core ASN.1 encoding details. */
|
---|
1333 | RTASN1CORE Asn1Core;
|
---|
1334 | } RTASN1CONTEXTTAG;
|
---|
1335 | /** Pointer to an ASN.1 context tag (IPRT thing). */
|
---|
1336 | typedef RTASN1CONTEXTTAG *PRTASN1CONTEXTTAG;
|
---|
1337 | /** Pointer to a const ASN.1 context tag (IPRT thing). */
|
---|
1338 | typedef RTASN1CONTEXTTAG const *PCRTASN1CONTEXTTAG;
|
---|
1339 |
|
---|
1340 | RTDECL(int) RTAsn1ContextTagN_Init(PRTASN1CONTEXTTAG pThis, uint32_t uTag, PCRTASN1COREVTABLE pVtable);
|
---|
1341 | RTDECL(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)
|
---|
1358 | RTASN1CONTEXTTAG_DO_TYPEDEF_AND_INLINE(0);
|
---|
1359 | RTASN1CONTEXTTAG_DO_TYPEDEF_AND_INLINE(1);
|
---|
1360 | RTASN1CONTEXTTAG_DO_TYPEDEF_AND_INLINE(2);
|
---|
1361 | RTASN1CONTEXTTAG_DO_TYPEDEF_AND_INLINE(3);
|
---|
1362 | RTASN1CONTEXTTAG_DO_TYPEDEF_AND_INLINE(4);
|
---|
1363 | RTASN1CONTEXTTAG_DO_TYPEDEF_AND_INLINE(5);
|
---|
1364 | RTASN1CONTEXTTAG_DO_TYPEDEF_AND_INLINE(6);
|
---|
1365 | RTASN1CONTEXTTAG_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 | */
|
---|
1398 | typedef 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 | */
|
---|
1436 | typedef 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. */
|
---|
1474 | typedef RTASN1DYNTYPE *PRTASN1DYNTYPE;
|
---|
1475 | /** Pointer to a const ASN.1 dynamic type record. */
|
---|
1476 | typedef RTASN1DYNTYPE const *PCRTASN1DYNTYPE;
|
---|
1477 | RTASN1TYPE_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 | */
|
---|
1487 | RTDECL(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 | */
|
---|
1501 | RTDECL(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 | */
|
---|
1516 | RTDECL(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 | */
|
---|
1525 | RTDECL(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 | */
|
---|
1538 | RTDECL(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 | */
|
---|
1569 | RTDECL(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 | */
|
---|
1586 | RTDECL(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 | */
|
---|
1602 | RTDECL(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 | */
|
---|
1617 | RTDECL(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 | */
|
---|
1633 | RTDECL(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 | */
|
---|
1654 | RTDECL(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 | */
|
---|
1667 | typedef 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 |
|
---|
1698 | typedef 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;
|
---|
1709 | typedef 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 | */
|
---|
1730 | RTDECL(PRTASN1CURSOR) RTAsn1CursorInitPrimary(PRTASN1CURSORPRIMARY pPrimaryCursor, void const *pvFirst, uint32_t cb,
|
---|
1731 | PRTERRINFO pErrInfo, PCRTASN1ALLOCATORVTABLE pAllocator, uint32_t fFlags,
|
---|
1732 | const char *pszErrorTag);
|
---|
1733 |
|
---|
1734 | RTDECL(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 | */
|
---|
1746 | RTDECL(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 | */
|
---|
1761 | RTDECL(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 | */
|
---|
1774 | RTDECL(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 | */
|
---|
1786 | RTDECL(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 | */
|
---|
1797 | RTDECL(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 | */
|
---|
1808 | RTDECL(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 | */
|
---|
1816 | RTDECL(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 | */
|
---|
1831 | RTDECL(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 | */
|
---|
1845 | RTDECL(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 | */
|
---|
1862 | RTDECL(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 | */
|
---|
1873 | DECLINLINE(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 | */
|
---|
1898 | RTDECL(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 | */
|
---|
1915 | RTDECL(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 | */
|
---|
1931 | DECLINLINE(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 | */
|
---|
1955 | DECLINLINE(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 | */
|
---|
1981 | RTDECL(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 | */
|
---|
1992 | RTDECL(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 | */
|
---|
2003 | RTDECL(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 | */
|
---|
2014 | RTDECL(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 | */
|
---|
2025 | RTDECL(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 | */
|
---|
2037 | RTDECL(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 | */
|
---|
2049 | RTDECL(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 | */
|
---|
2060 | RTDECL(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 | */
|
---|
2075 | RTDECL(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 | */
|
---|
2087 | RTDECL(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 | */
|
---|
2099 | RTDECL(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 | */
|
---|
2110 | RTDECL(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 | */
|
---|
2121 | RTDECL(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 | */
|
---|
2132 | RTDECL(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 | */
|
---|
2145 | RTDECL(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 | */
|
---|
2159 | RTDECL(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 | */
|
---|
2180 | RTDECL(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 | */
|
---|
2193 | RTDECL(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 | */
|
---|
2202 | RTDECL(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 | */
|
---|
2212 | RTDECL(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 |
|
---|
2243 | RTASN1CONTEXTTAG_IMPL_CURSOR_INLINES(0)
|
---|
2244 | RTASN1CONTEXTTAG_IMPL_CURSOR_INLINES(1)
|
---|
2245 | RTASN1CONTEXTTAG_IMPL_CURSOR_INLINES(2)
|
---|
2246 | RTASN1CONTEXTTAG_IMPL_CURSOR_INLINES(3)
|
---|
2247 | RTASN1CONTEXTTAG_IMPL_CURSOR_INLINES(4)
|
---|
2248 | RTASN1CONTEXTTAG_IMPL_CURSOR_INLINES(5)
|
---|
2249 | RTASN1CONTEXTTAG_IMPL_CURSOR_INLINES(6)
|
---|
2250 | RTASN1CONTEXTTAG_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 | */
|
---|
2261 | DECLINLINE(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 | */
|
---|
2274 | DECLINLINE(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 | */
|
---|
2296 | RTDECL(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 | */
|
---|
2312 | RTDECL(int) RTAsn1QueryObjIdName(PCRTASN1OBJID pObjId, char *pszDst, size_t cbDst);
|
---|
2313 |
|
---|
2314 | /** @} */
|
---|
2315 |
|
---|
2316 | /** @} */
|
---|
2317 |
|
---|
2318 | RT_C_DECLS_END
|
---|
2319 |
|
---|
2320 | #endif /* !IPRT_INCLUDED_asn1_h */
|
---|
2321 |
|
---|