asn1-ut-bitstring.cpp

Last change on this file was 106061, checked in by vboxsync, 6 weeks ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 19.7 KB

Line
1	/* $Id: asn1-ut-bitstring.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
2	/** @file
3	* IPRT - ASN.1, Bit String Type.
4	*
5	* @remarks This file should remain very similar to asn1-ut-octetstring.cpp.
6	*/
7
8	/*
9	* Copyright (C) 2006-2024 Oracle and/or its affiliates.
10	*
11	* This file is part of VirtualBox base platform packages, as
12	* available from https://www.virtualbox.org.
13	*
14	* This program is free software; you can redistribute it and/or
15	* modify it under the terms of the GNU General Public License
16	* as published by the Free Software Foundation, in version 3 of the
17	* License.
18	*
19	* This program is distributed in the hope that it will be useful, but
20	* WITHOUT ANY WARRANTY; without even the implied warranty of
21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22	* General Public License for more details.
23	*
24	* You should have received a copy of the GNU General Public License
25	* along with this program; if not, see <https://www.gnu.org/licenses>.
26	*
27	* The contents of this file may alternatively be used under the terms
28	* of the Common Development and Distribution License Version 1.0
29	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
30	* in the VirtualBox distribution, in which case the provisions of the
31	* CDDL are applicable instead of those of the GPL.
32	*
33	* You may elect to license modified versions of this file under the
34	* terms and conditions of either the GPL or the CDDL or both.
35	*
36	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
37	*/
38
39
40	/*********************************************************************************************************************************
41	* Header Files *
42	*********************************************************************************************************************************/
43	#include "internal/iprt.h"
44	#include <iprt/asn1.h>
45
46	#include <iprt/alloca.h>
47	#include <iprt/bignum.h>
48	#include <iprt/ctype.h>
49	#include <iprt/err.h>
50	#include <iprt/string.h>
51	#include <iprt/uni.h>
52
53	#include <iprt/formats/asn1.h>
54
55
56	/*********************************************************************************************************************************
57	* Structures and Typedefs *
58	*********************************************************************************************************************************/
59	typedef struct RTASN1BITSTRINGWRITERCTX
60	{
61	/** Pointer to the output buffer. */
62	uint8_t *pbBuf;
63	/** The current buffer offset. */
64	uint32_t offBuf;
65	/** The size of the buffer. */
66	uint32_t cbBuf;
67	} RTASN1BITSTRINGWRITERCTX;
68
69
70	/** @callback_method_impl{FNRTASN1ENCODEWRITER,
71	* Used to refresh the content of octet and bit strings. } */
72	static DECLCALLBACK(int) rtAsn1BitStringEncodeWriter(const void pvBuf, size_t cbToWrite, void pvUser, PRTERRINFO pErrInfo)
73	{
74	RTASN1BITSTRINGWRITERCTX pCtx = (RTASN1BITSTRINGWRITERCTX )pvUser;
75	AssertReturn(cbToWrite <= pCtx->cbBuf - pCtx->offBuf,
76	RTErrInfoSetF(pErrInfo, VERR_BUFFER_OVERFLOW,
77	"cbToWrite=%#x offBuf=%#x cbBuf=%#x", cbToWrite, pCtx->cbBuf, pCtx->offBuf));
78	memcpy(&pCtx->pbBuf[pCtx->offBuf], pvBuf, cbToWrite);
79	pCtx->offBuf += (uint32_t)cbToWrite;
80	return VINF_SUCCESS;
81	}
82
83
84	/** @callback_method_impl{FNRTASN1ENCODEWRITER,
85	* Used to compare the encoded raw content of an octet or bit string with the
86	* encapsulated object. } */
87	static DECLCALLBACK(int) rtAsn1BitStringEncodeCompare(const void pvBuf, size_t cbToWrite, void pvUser, PRTERRINFO pErrInfo)
88	{
89	RTASN1BITSTRINGWRITERCTX pCtx = (RTASN1BITSTRINGWRITERCTX )pvUser;
90	AssertReturn(cbToWrite <= pCtx->cbBuf - pCtx->offBuf, VERR_BUFFER_OVERFLOW);
91	if (memcmp(&pCtx->pbBuf[pCtx->offBuf], pvBuf, cbToWrite) != 0)
92	return VERR_NOT_EQUAL;
93	pCtx->offBuf += (uint32_t)cbToWrite;
94	RT_NOREF_PV(pErrInfo);
95	return VINF_SUCCESS;
96	}
97
98
99
100	/*
101	* ASN.1 BIT STRING - Special Methods.
102	*/
103
104	RTDECL(uint64_t) RTAsn1BitString_GetAsUInt64(PCRTASN1BITSTRING pThis)
105	{
106	/*
107	* Extract the first 64 bits in host order.
108	*/
109	uint8_t const *pb = pThis->uBits.pu8;
110	uint64_t uRet = 0;
111	uint32_t cShift = 0;
112	uint32_t cBits = RT_MIN(pThis->cBits, 64);
113	while (cBits > 0)
114	{
115	uint8_t b = *pb++;
116	#if 1 /* We don't have a bit-order constant... */
117	b = ((b & 0x01) << 7)
118	\| ((b & 0x02) << 5)
119	\| ((b & 0x04) << 3)
120	\| ((b & 0x08) << 1)
121	\| ((b & 0x10) >> 1)
122	\| ((b & 0x20) >> 3)
123	\| ((b & 0x40) >> 5)
124	\| ((b & 0x80) >> 7);
125	#endif
126	if (cBits < 8)
127	{
128	b &= RT_BIT_32(cBits) - 1;
129	uRet \|= (uint64_t)b << cShift;
130	break;
131	}
132	uRet \|= (uint64_t)b << cShift;
133	cShift += 8;
134	cBits -= 8;
135	}
136
137	return uRet;
138	}
139
140
141	RTDECL(int) RTAsn1BitString_RefreshContent(PRTASN1BITSTRING pThis, uint32_t fFlags,
142	PCRTASN1ALLOCATORVTABLE pAllocator, PRTERRINFO pErrInfo)
143	{
144	AssertReturn(pThis->pEncapsulated, VERR_INVALID_STATE);
145
146	uint32_t cbEncoded;
147	int rc = RTAsn1EncodePrepare(pThis->pEncapsulated, fFlags, &cbEncoded, pErrInfo);
148	if (RT_SUCCESS(rc))
149	{
150	pThis->Asn1Core.cb = 1 + cbEncoded;
151	pThis->cBits = cbEncoded * 8;
152	AssertReturn(pThis->cBits / 8 == cbEncoded, RTErrInfoSetF(pErrInfo, VERR_TOO_MUCH_DATA, "cbEncoded=%#x", cbEncoded));
153
154	rc = RTAsn1ContentReallocZ(&pThis->Asn1Core, cbEncoded + 1, pAllocator);
155	if (RT_SUCCESS(rc))
156	{
157	pThis->uBits.pu8 = pThis->Asn1Core.uData.pu8 + 1;
158
159	/* Initialize the writer context and write the first byte concerning unused bits. */
160	RTASN1BITSTRINGWRITERCTX Ctx;
161	Ctx.pbBuf = (uint8_t *)pThis->Asn1Core.uData.pu8;
162	Ctx.cbBuf = cbEncoded + 1;
163	Ctx.offBuf = 1;
164	*Ctx.pbBuf = 0;
165
166	rc = RTAsn1EncodeWrite(pThis->pEncapsulated, fFlags, rtAsn1BitStringEncodeWriter, &Ctx, pErrInfo);
167	if (RT_SUCCESS(rc))
168	{
169	if (Ctx.offBuf == cbEncoded + 1)
170	return VINF_SUCCESS;
171
172	rc = RTErrInfoSetF(pErrInfo, rc, "Expected %#x + 1 bytes, got %#x", cbEncoded, Ctx.offBuf);
173	}
174	}
175	else
176	rc = RTErrInfoSetF(pErrInfo, rc, "Error allocating %#x + 1 bytes for storing content\n", cbEncoded);
177	}
178	return rc;
179	}
180
181
182	RTDECL(bool) RTAsn1BitString_AreContentBitsValid(PCRTASN1BITSTRING pThis, uint32_t fFlags)
183	{
184	if (pThis->pEncapsulated)
185	{
186	if (pThis->cBits & 7)
187	return false;
188
189	/* Check the encoded length of the bits. */
190	uint32_t cbEncoded;
191	int rc = RTAsn1EncodePrepare(pThis->pEncapsulated, fFlags, &cbEncoded, NULL);
192	if (RT_FAILURE(rc))
193	return false;
194	if (pThis->Asn1Core.cb != 1 + cbEncoded)
195	return false;
196
197	/* Check the encoded bits, if there are any. */
198	if (cbEncoded)
199	{
200	if (!pThis->Asn1Core.uData.pv)
201	return false;
202
203	/* Check the first byte, the unused bit count. */
204	if (*pThis->Asn1Core.uData.pu8 != 0)
205	return false;
206
207	/* Check the other bytes. */
208	RTASN1BITSTRINGWRITERCTX Ctx;
209	Ctx.pbBuf = (uint8_t *)pThis->Asn1Core.uData.pu8;
210	Ctx.cbBuf = cbEncoded + 1;
211	Ctx.offBuf = 1;
212	rc = RTAsn1EncodeWrite(pThis->pEncapsulated, fFlags, rtAsn1BitStringEncodeCompare, &Ctx, NULL);
213	if (RT_FAILURE(rc))
214	return false;
215	}
216	}
217	return true;
218	}
219
220
221
222
223	/*
224	* ASN.1 BIT STRING - Standard Methods.
225	*/
226
227	/** @interface_method_impl{FNRTASN1COREVTENCODEPREP} */
228	static DECLCALLBACK(int) RTAsn1BitString_EncodePrep(PRTASN1CORE pThisCore, uint32_t fFlags, PRTERRINFO pErrInfo)
229	{
230	PRTASN1BITSTRING pThis = (PRTASN1BITSTRING)pThisCore;
231	if (!pThis->pEncapsulated)
232	{
233	Assert(pThis->cBits == 0 \|\| pThis->Asn1Core.uData.pv);
234	return VINF_SUCCESS;
235	}
236
237	/* Figure out the size of the encapsulated content. */
238	uint32_t cbEncoded;
239	int rc = RTAsn1EncodePrepare(pThis->pEncapsulated, fFlags, &cbEncoded, pErrInfo);
240	if (RT_SUCCESS(rc))
241	{
242	/* Free the bytes if they don't match up. */
243	if (pThis->Asn1Core.uData.pv)
244	{
245	bool fMustFree = pThis->Asn1Core.cb != 1 + cbEncoded \|\| (pThis->cBits & 7);
246	if (!fMustFree)
247	{
248	RTASN1BITSTRINGWRITERCTX Ctx;
249	Ctx.pbBuf = (uint8_t *)pThis->Asn1Core.uData.pu8;
250	Ctx.cbBuf = 1 + cbEncoded;
251	Ctx.offBuf = 1;
252	fMustFree = *Ctx.pbBuf != 0;
253	if (!fMustFree)
254	{
255	rc = RTAsn1EncodeWrite(pThis->pEncapsulated, fFlags, rtAsn1BitStringEncodeCompare, &Ctx, NULL);
256	fMustFree = RT_FAILURE_NP(rc);
257	}
258	}
259	if (fMustFree)
260	{
261	pThis->uBits.pv = NULL;
262	RTAsn1ContentFree(&pThis->Asn1Core);
263	}
264	}
265	pThis->Asn1Core.cb = 1 + cbEncoded;
266	pThis->cBits = cbEncoded * 8;
267
268	rc = RTAsn1EncodeRecalcHdrSize(&pThis->Asn1Core, fFlags, pErrInfo);
269	}
270	return rc;
271	}
272
273
274	/** @interface_method_impl{FNRTASN1COREVTENCODEWRITE} */
275	static DECLCALLBACK(int) RTAsn1BitString_EncodeWrite(PRTASN1CORE pThisCore, uint32_t fFlags, PFNRTASN1ENCODEWRITER pfnWriter,
276	void *pvUser, PRTERRINFO pErrInfo)
277	{
278	PRTASN1BITSTRING pThis = (PRTASN1BITSTRING)pThisCore;
279
280	AssertReturn(RT_ALIGN(pThis->cBits, 8) / 8 + 1 == pThis->Asn1Core.cb, VERR_INTERNAL_ERROR_3);
281
282	/*
283	* First the header.
284	*/
285	int rc = RTAsn1EncodeWriteHeader(&pThis->Asn1Core, fFlags, pfnWriter, pvUser, pErrInfo);
286	if (RT_SUCCESS(rc) && rc != VINF_ASN1_NOT_ENCODED)
287	{
288	/*
289	* The content starts with an unused bit count. Calculate it in case we
290	* need to write it out.
291	*/
292	uint8_t cUnusedBits = 0;
293	if ((pThis->cBits & 7) != 0)
294	cUnusedBits = 8 - (pThis->cBits & 7);
295
296	/*
297	* If nothing is encapsulated, the core points to the content (if we have any).
298	*/
299	if (!pThis->pEncapsulated)
300	{
301	if (pThis->cBits > 0)
302	{
303	Assert(pThis->Asn1Core.uData.pu8[0] == cUnusedBits);
304	rc = pfnWriter(pThis->Asn1Core.uData.pu8, pThis->Asn1Core.cb, pvUser, pErrInfo);
305	}
306	else
307	rc = pfnWriter(&cUnusedBits, sizeof(cUnusedBits), pvUser, pErrInfo);
308	}
309	/*
310	* Write the unused bit count and then call upon the encapsulated
311	* content to serialize itself.
312	*/
313	else
314	{
315	rc = pfnWriter(&cUnusedBits, sizeof(cUnusedBits), pvUser, pErrInfo);
316	if (RT_SUCCESS(rc))
317	rc = RTAsn1EncodeWrite(pThis->pEncapsulated, fFlags, pfnWriter, pvUser, pErrInfo);
318	}
319	}
320	return rc;
321	}
322
323
324	RT_DECL_DATA_CONST(RTASN1COREVTABLE const) g_RTAsn1BitString_Vtable =
325	{
326	"RTAsn1BitString",
327	sizeof(RTASN1BITSTRING),
328	ASN1_TAG_BIT_STRING,
329	ASN1_TAGCLASS_UNIVERSAL \| ASN1_TAGFLAG_PRIMITIVE,
330	0,
331	(PFNRTASN1COREVTDTOR)RTAsn1BitString_Delete,
332	(PFNRTASN1COREVTENUM)RTAsn1BitString_Enum,
333	(PFNRTASN1COREVTCLONE)RTAsn1BitString_Clone,
334	(PFNRTASN1COREVTCOMPARE)RTAsn1BitString_Compare,
335	(PFNRTASN1COREVTCHECKSANITY)RTAsn1BitString_CheckSanity,
336	RTAsn1BitString_EncodePrep,
337	RTAsn1BitString_EncodeWrite
338	};
339
340
341	RTDECL(int) RTAsn1BitString_Init(PRTASN1BITSTRING pThis, PCRTASN1ALLOCATORVTABLE pAllocator)
342	{
343	RT_ZERO(*pThis);
344
345	RTAsn1Core_InitEx(&pThis->Asn1Core, ASN1_TAG_BIT_STRING, ASN1_TAGCLASS_UNIVERSAL \| ASN1_TAGFLAG_PRIMITIVE,
346	&g_RTAsn1BitString_Vtable, RTASN1CORE_F_PRESENT \| RTASN1CORE_F_PRIMITE_TAG_STRUCT);
347	/*pThis->cBits = 0;
348	pThis->cMaxBits = 0;
349	pThis->uBits.pv = NULL;
350	pThis->pEncapsulated = NULL; */
351	RTAsn1MemInitAllocation(&pThis->EncapsulatedAllocation, pAllocator);
352
353	return VINF_SUCCESS;
354	}
355
356
357	RTDECL(int) RTAsn1BitString_InitWithData(PRTASN1BITSTRING pThis, void const *pvSrc, uint32_t cSrcBits,
358	PCRTASN1ALLOCATORVTABLE pAllocator)
359	{
360	RTAsn1BitString_Init(pThis, pAllocator);
361	Assert(pThis->pEncapsulated == NULL);
362
363	uint32_t cbToCopy = (cSrcBits + 7) / 8;
364	int rc = RTAsn1ContentAllocZ(&pThis->Asn1Core, cbToCopy + 1, pAllocator);
365	if (RT_SUCCESS(rc))
366	{
367	pThis->cBits = cSrcBits;
368	uint8_t pbDst = (uint8_t )pThis->Asn1Core.uData.pu8;
369	pThis->uBits.pv = pbDst + 1;
370	pbDst = (cSrcBits & 7) != 0 ? 8 - (cSrcBits & 7) : 0; / unused bits */
371	memcpy(pbDst + 1, pvSrc, cbToCopy);
372	}
373	return rc;
374	}
375
376
377	RTDECL(int) RTAsn1BitString_Clone(PRTASN1BITSTRING pThis, PCRTASN1BITSTRING pSrc, PCRTASN1ALLOCATORVTABLE pAllocator)
378	{
379	AssertPtr(pSrc); AssertPtr(pThis); AssertPtr(pAllocator);
380
381	RT_ZERO(*pThis);
382	if (RTAsn1BitString_IsPresent(pSrc))
383	{
384	AssertReturn(pSrc->Asn1Core.pOps == &g_RTAsn1BitString_Vtable, VERR_INTERNAL_ERROR_3);
385
386	int rc;
387	if (!pSrc->pEncapsulated)
388	rc = RTAsn1Core_CloneContent(&pThis->Asn1Core, &pSrc->Asn1Core, pAllocator);
389	else
390	rc = RTAsn1Core_CloneNoContent(&pThis->Asn1Core, &pSrc->Asn1Core);
391	if (RT_FAILURE(rc))
392	return rc;
393
394	RTAsn1MemInitAllocation(&pThis->EncapsulatedAllocation, pAllocator);
395	pThis->cBits = pSrc->cBits;
396	pThis->cMaxBits = pSrc->cMaxBits;
397	if (!pSrc->pEncapsulated)
398	pThis->uBits.pv = pThis->Asn1Core.uData.pu8 ? pThis->Asn1Core.uData.pu8 + 1 : NULL;
399	else
400	{
401	PCRTASN1COREVTABLE pOps = pSrc->pEncapsulated->pOps;
402	Assert(!pOps \|\| pOps->pfnClone);
403	if (pOps && pOps->pfnClone)
404	{
405	/* We can clone the decoded encapsulated object. */
406	rc = RTAsn1MemAllocZ(&pThis->EncapsulatedAllocation, (void **)&pThis->pEncapsulated, pOps->cbStruct);
407	if (RT_SUCCESS(rc))
408	{
409	rc = pOps->pfnClone(pThis->pEncapsulated, pSrc->pEncapsulated, pAllocator);
410	if (RT_FAILURE(rc))
411	RTAsn1MemFree(&pThis->EncapsulatedAllocation, pThis->pEncapsulated);
412	}
413	}
414	else
415	{
416	/* Borrow the encapsulated pointer and use RTAsn1BitString_RefreshContent
417	to get an accurate copy of the bytes. */
418	pThis->pEncapsulated = pSrc->pEncapsulated;
419	rc = RTAsn1BitString_RefreshContent(pThis, RTASN1ENCODE_F_DER, pAllocator, NULL);
420	pThis->pEncapsulated = NULL;
421	}
422	if (RT_FAILURE(rc))
423	{
424	RTAsn1ContentFree(&pThis->Asn1Core);
425	RT_ZERO(*pThis);
426	return rc;
427	}
428	}
429	}
430	return VINF_SUCCESS;
431	}
432
433
434	RTDECL(void) RTAsn1BitString_Delete(PRTASN1BITSTRING pThis)
435	{
436	if ( pThis
437	&& RTAsn1BitString_IsPresent(pThis))
438	{
439	Assert(pThis->Asn1Core.pOps == &g_RTAsn1BitString_Vtable);
440
441	/* Destroy the encapsulated object. */
442	if (pThis->pEncapsulated)
443	{
444	RTAsn1VtDelete(pThis->pEncapsulated);
445	if (pThis->EncapsulatedAllocation.cbAllocated)
446	RTAsn1MemFree(&pThis->EncapsulatedAllocation, pThis->pEncapsulated);
447	}
448
449	/* Delete content and wipe the content. */
450	RTAsn1ContentFree(&pThis->Asn1Core);
451	RT_ZERO(*pThis);
452	}
453	}
454
455
456	RTDECL(int) RTAsn1BitString_Enum(PRTASN1BITSTRING pThis, PFNRTASN1ENUMCALLBACK pfnCallback, uint32_t uDepth, void *pvUser)
457	{
458	Assert(pThis && (!RTAsn1BitString_IsPresent(pThis) \|\| pThis->Asn1Core.pOps == &g_RTAsn1BitString_Vtable));
459
460	/* Enumerate the encapsulated object if present. */
461	if (pThis->pEncapsulated)
462	return pfnCallback(pThis->pEncapsulated, "Encapsulated", uDepth + 1, pvUser);
463	return VINF_SUCCESS;
464	}
465
466
467	RTDECL(int) RTAsn1BitString_Compare(PCRTASN1BITSTRING pLeft, PCRTASN1BITSTRING pRight)
468	{
469	Assert(pLeft && (!RTAsn1BitString_IsPresent(pLeft) \|\| pLeft->Asn1Core.pOps == &g_RTAsn1BitString_Vtable));
470	Assert(pRight && (!RTAsn1BitString_IsPresent(pRight) \|\| pRight->Asn1Core.pOps == &g_RTAsn1BitString_Vtable));
471
472	int iDiff;
473	if (RTAsn1BitString_IsPresent(pLeft))
474	{
475	if (RTAsn1BitString_IsPresent(pRight))
476	{
477	/* Since it's really hard to tell whether encapsulated objects have
478	been modified or not, we might have to refresh both objects
479	while doing this compare. We'll try our best to avoid it though. */
480	if (pLeft->pEncapsulated \|\| pRight->pEncapsulated)
481	{
482	if ( pLeft->pEncapsulated
483	&& pRight->pEncapsulated
484	&& pLeft->pEncapsulated->pOps == pRight->pEncapsulated->pOps)
485	iDiff = pLeft->pEncapsulated->pOps->pfnCompare(pLeft->pEncapsulated, pRight->pEncapsulated);
486	else
487	{
488	/* No direct comparison of encapsulated objects possible,
489	make sure we've got the rigth bytes then. */
490	if ( pLeft->pEncapsulated
491	&& !RTAsn1BitString_AreContentBitsValid(pLeft, RTASN1ENCODE_F_DER))
492	{
493	int rc = RTAsn1BitString_RefreshContent((PRTASN1BITSTRING)pLeft, RTASN1ENCODE_F_DER,
494	pLeft->EncapsulatedAllocation.pAllocator, NULL);
495	AssertRC(rc);
496	}
497
498	if ( pRight->pEncapsulated
499	&& !RTAsn1BitString_AreContentBitsValid(pRight, RTASN1ENCODE_F_DER))
500	{
501	int rc = RTAsn1BitString_RefreshContent((PRTASN1BITSTRING)pRight, RTASN1ENCODE_F_DER,
502	pRight->EncapsulatedAllocation.pAllocator, NULL);
503	AssertRC(rc);
504	}
505
506	/* Compare the content bytes. */
507	iDiff = RTAsn1Core_CompareEx(&pLeft->Asn1Core, &pRight->Asn1Core, true /fIgnoreTagAndClass/);
508	}
509	}
510	/*
511	* No encapsulated object, just compare the raw content bytes.
512	*/
513	else
514	iDiff = RTAsn1Core_CompareEx(&pLeft->Asn1Core, &pRight->Asn1Core, true /fIgnoreTagAndClass/);
515	}
516	else
517	iDiff = -1;
518	}
519	else
520	iDiff = 0 - (int)RTAsn1BitString_IsPresent(pRight);
521	return iDiff;
522	}
523
524
525	RTDECL(int) RTAsn1BitString_CheckSanity(PCRTASN1BITSTRING pThis, uint32_t fFlags, PRTERRINFO pErrInfo, const char *pszErrorTag)
526	{
527	if (RT_UNLIKELY(!RTAsn1BitString_IsPresent(pThis)))
528	return RTErrInfoSetF(pErrInfo, VERR_ASN1_NOT_PRESENT, "%s: Missing (BIT STRING).", pszErrorTag);
529
530	if (pThis->cBits > pThis->cMaxBits)
531	return RTErrInfoSetF(pErrInfo, VERR_ASN1_BITSTRING_OUT_OF_BOUNDS, "%s: Exceeding max bits: cBits=%u cMaxBits=%u.",
532	pszErrorTag, pThis->cBits, pThis->cMaxBits);
533
534	if (pThis->pEncapsulated)
535	return pThis->pEncapsulated->pOps->pfnCheckSanity(pThis->pEncapsulated, fFlags & RTASN1_CHECK_SANITY_F_COMMON_MASK,
536	pErrInfo, pszErrorTag);
537	return VINF_SUCCESS;
538	}
539
540	/*
541	* Generate code for the associated collection types.
542	*/
543	#define RTASN1TMPL_TEMPLATE_FILE "../common/asn1/asn1-ut-bitstring-template.h"
544	#include <iprt/asn1-generator-internal-header.h>
545	#include <iprt/asn1-generator-core.h>
546	#include <iprt/asn1-generator-init.h>
547	#include <iprt/asn1-generator-sanity.h>
548

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/common/asn1/asn1-ut-bitstring.cpp

Download in other formats: